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

package/src/config/ai-agent-paths.js

@@ -32,10 +32,9 @@ export const AI_AGENT_PATHS = {
       project: '.claude/skills/',
       user: join(homedir(), '.claude', 'skills')
     },
-    commands: {
-      project: '.claude/commands/',
-      user: join(homedir(), '.claude', 'commands')
-    },
+    // v2.1.3+: Commands and Skills merged, unified to Skills
+    // See: "Merged slash commands and skills, simplifying the mental model with no change in behavior."
+    commands: null,
     agents: {
       project: '.claude/agents/',
       user: join(homedir(), '.claude', 'agents')
@@ -80,7 +79,10 @@ export const AI_AGENT_PATHS = {
       project: '.cursor/skills/',
       user: join(homedir(), '.cursor', 'skills')
     },
-    commands: null, // Rules only, no SKILL.md support yet
+    commands: {
+      project: '.cursor/commands/',
+      user: join(homedir(), '.cursor', 'commands')
+    },
     agents: {
       project: '.cursor/agents/',
       user: join(homedir(), '.cursor', 'agents')
@@ -88,25 +90,25 @@ export const AI_AGENT_PATHS = {
     workflows: null, // Not supported
     supportsMarketplace: false,
     fallbackSkillsPath: '.claude/skills/',
-    supportsSkills: false, // Uses .mdc rules format
+    supportsSkills: true, // SKILL.md support since v2.4 (Jan 22, 2026)
     supportsTask: false, // No Task tool support
     supportsAgents: true // Can load agents as inline context
   },
   'cline': {
     name: 'Cline',
     skills: {
-      project: '.clinerules/skills/',
-      user: join(homedir(), '.clinerules', 'skills')
+      project: '.cline/skills/',
+      user: join(homedir(), '.cline', 'skills')
     },
     commands: null, // Uses workflow files
     agents: {
-      project: '.clinerules/agents/',
-      user: join(homedir(), '.clinerules', 'agents')
+      project: '.cline/agents/',
+      user: join(homedir(), '.cline', 'agents')
     },
     workflows: {
       // Official path per docs.cline.bot/features/slash-commands/workflows
-      project: '.clinerules/workflows/',
-      user: join(homedir(), '.clinerules', 'workflows')
+      project: '.cline/workflows/',
+      user: join(homedir(), '.cline', 'workflows')
     },
     supportsMarketplace: false,
     fallbackSkillsPath: '.claude/skills/',
@@ -224,22 +226,22 @@ export const AI_AGENT_PATHS = {
     commandFormat: 'toml',
     supportsMarketplace: false,
     fallbackSkillsPath: '.claude/skills/',
-    supportsSkills: true, // Preview support
+    supportsSkills: true, // Stable since v0.27.0 (Feb 2026)
     supportsTask: false,
     supportsAgents: true
   },
   'antigravity': {
     name: 'Google Antigravity',
     skills: {
-      project: '.antigravity/skills/',
-      user: join(homedir(), '.antigravity', 'skills')
+      project: '.agent/skills/',
+      user: join(homedir(), '.gemini', 'antigravity', 'skills')
     },
     commands: null,
     agents: null,
     workflows: null,
     supportsMarketplace: false,
     fallbackSkillsPath: null,
-    supportsSkills: false,
+    supportsSkills: true, // Skills since Nov 2025
     supportsTask: false,
     supportsAgents: false
   }
@@ -431,28 +433,86 @@ export function supportsAgents(agent) {
 }
 
 /**
- * List of all available slash commands (from skills/claude-code/commands/)
+ * List of all available slash commands (from skills/)
+ * Note: Since Claude Code v2.1.3+, Skills and Commands are merged.
+ * The `name` field in SKILL.md directly becomes the slash command.
+ *
+ * This list includes:
+ * - 16 commands from Action Skills (SKILL.md files with `name` field)
+ * - 12 commands from Commands-only files (no corresponding Skill)
+ * Total: 28 available commands
+ *
+ * Reference-only Skills (no `name` field, not slash commands):
+ * testing-guide, project-structure-guide, git-workflow-guide,
+ * error-code-guide, logging-guide, ai-collaboration-standards,
+ * ai-friendly-architecture, ai-instruction-standards, documentation-guide
  */
 export const AVAILABLE_COMMANDS = [
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Core Development Workflow (Action Skills)
+  // ═══════════════════════════════════════════════════════════════════════════
   { name: 'commit', description: 'Generate commit messages following Conventional Commits' },
   { name: 'review', description: 'Perform code review with checklist' },
-  { name: 'tdd', description: 'Guide TDD workflow (Red-Green-Refactor)' },
-  { name: 'bdd', description: 'Guide BDD workflow' },
-  { name: 'coverage', description: 'Analyze test coverage' },
-  { name: 'requirement', description: 'Write requirements following INVEST' },
-  { name: 'check', description: 'Check-in verification' },
+  { name: 'checkin', description: 'Pre-commit quality gates verification' },
   { name: 'release', description: 'Guide release process' },
   { name: 'changelog', description: 'Generate changelog entries' },
-  { name: 'docs', description: 'Generate documentation' },
-  { name: 'spec', description: 'Spec-driven development guide' },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Testing Methodologies (Action Skills)
+  // ═══════════════════════════════════════════════════════════════════════════
+  { name: 'tdd', description: 'Guide TDD workflow (Red-Green-Refactor)' },
+  { name: 'bdd', description: 'Guide BDD workflow (Gherkin, Given-When-Then)' },
+  { name: 'atdd', description: 'Guide ATDD workflow (acceptance criteria)' },
+  { name: 'coverage', description: 'Analyze test coverage (8 dimensions)' },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Specification and Requirements (Action Skills)
+  // ═══════════════════════════════════════════════════════════════════════════
+  { name: 'sdd', description: 'Spec-driven development guide' },
+  { name: 'requirement', description: 'Write requirements following INVEST' },
+  { name: 'derive', description: 'Forward derivation (spec to BDD/TDD)' },
+  { name: 'reverse', description: 'Reverse engineer code to SDD specs' },
+  { name: 'discover', description: 'Assess project health and risks before adding features' },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Derivation Commands (Commands-only, specific transformations)
+  // ═══════════════════════════════════════════════════════════════════════════
+  { name: 'derive-bdd', description: 'Derive BDD Gherkin scenarios from SDD specification' },
+  { name: 'derive-tdd', description: 'Derive TDD test skeletons from SDD specification' },
+  { name: 'derive-atdd', description: 'Derive ATDD acceptance tests from SDD specification' },
+  { name: 'derive-all', description: 'Derive all test structures (BDD, TDD, ATDD) from spec' },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Reverse Engineering Commands (Commands-only, specific transformations)
+  // ═══════════════════════════════════════════════════════════════════════════
+  { name: 'reverse-sdd', description: 'Reverse engineer code into SDD specification document' },
+  { name: 'reverse-bdd', description: 'Transform SDD acceptance criteria to BDD scenarios' },
+  { name: 'reverse-tdd', description: 'Analyze BDD-TDD coverage gaps' },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Documentation and Code Quality (Action Skills + Commands-only)
+  // ═══════════════════════════════════════════════════════════════════════════
+  { name: 'docs', description: 'Manage, guide, and generate documentation' },
+  { name: 'docgen', description: 'Generate usage documentation' },
+  { name: 'guide', description: 'Access UDS guides and references' },
+  { name: 'refactor', description: 'Refactoring and legacy modernization guide' },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Development Methodology (Action Skills)
+  // ═══════════════════════════════════════════════════════════════════════════
   { name: 'methodology', description: 'Development methodology selection' },
-  { name: 'config', description: 'Project structure configuration' },
-  { name: 'init', description: 'Initialize standards' },
-  { name: 'update', description: 'Update standards' }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CLI Management (Commands-only, UDS CLI specific)
+  // ═══════════════════════════════════════════════════════════════════════════
+  { name: 'init', description: 'Initialize UDS standards in project' },
+  { name: 'update', description: 'Update standards to latest version' },
+  { name: 'check', description: 'Verify standards adoption status' },
+  { name: 'config', description: 'Configure project standards settings' }
 ];
 
 /**
- * List of all available agents (from skills/claude-code/agents/)
+ * List of all available agents (from skills/agents/)
  */
 export const AVAILABLE_AGENTS = [
   { name: 'code-architect', description: 'Software architecture and system design specialist' },
@@ -463,7 +523,7 @@ export const AVAILABLE_AGENTS = [
 ];
 
 /**
- * List of all available workflows (from skills/claude-code/workflows/)
+ * List of all available workflows (from skills/workflows/)
  */
 export const AVAILABLE_WORKFLOWS = [
   { name: 'integrated-flow', description: 'Complete ATDD → SDD → BDD → TDD workflow' },

package/src/core/constants.js

@@ -107,6 +107,13 @@ export const SUPPORTED_AI_TOOLS = {
     format: 'markdown',
     category: 'secondary',
     supports: ['skills', 'workflows']
+  },
+  'gemini-cli': {
+    name: 'Gemini CLI',
+    file: 'GEMINI.md',
+    format: 'markdown',
+    category: 'primary',
+    supports: ['skills', 'commands']
   }
 };
 
@@ -115,7 +122,6 @@ export const SUPPORTED_AI_TOOLS = {
  */
 export const LEGACY_TOOL_MAPPINGS = {
   'codex': 'opencode',
-  'gemini-cli': 'opencode',
   'copilot': 'github-copilot'
 };
 

package/src/core/manifest.js

@@ -46,6 +46,7 @@ export const DEFAULT_MANIFEST = {
   commands: {
     installed: false,
     names: [],
+    version: null,
     installations: []
   },
   methodology: null,

package/src/flows/init-flow.js

@@ -0,0 +1,243 @@
+import chalk from 'chalk';
+import { t } from '../i18n/messages.js';
+import {
+  promptDisplayLanguage,
+  promptAITools,
+  promptSkillsInstallLocation,
+  promptStandardsScope,
+  promptLevel,
+  promptLanguage,
+  promptFramework,
+  promptFormat,
+  promptStandardOptions,
+  promptContentMode,
+  promptMethodology,
+  promptCommandsInstallation,
+  handleAgentsMdSharing
+} from '../prompts/init.js';
+import {
+  promptIntegrationConfig
+} from '../prompts/integrations.js';
+import {
+  getAgentConfig,
+  getAgentDisplayName
+} from '../utils/github.js';
+import { getInstalledSkillsInfoForAgent } from '../utils/skills-installer.js';
+import { integrationFileExists } from '../utils/integration-generator.js';
+
+/**
+ * Execute the interactive initialization flow
+ * @param {Object} options - CLI options
+ * @param {Object} detected - Detected project environment
+ * @param {string} projectPath - Current project path
+ * @returns {Promise<Object|null>} Configuration object or null if cancelled
+ */
+export async function runInitFlow(options, detected, projectPath) {
+  let msg = t().commands.init;
+  
+  // Initialize configuration variables
+  let level = options.level ? parseInt(options.level, 10) : null;
+  let languages = options.lang ? [options.lang] : null;
+  let frameworks = options.framework ? [options.framework] : null;
+  let displayLanguage = options.locale || null;
+  let format = options.format || null;
+  let standardOptions = {};
+  
+  // Skills configuration
+  let skillsConfig = {
+    installed: false,
+    location: null,
+    needsInstall: false,
+    updateTargets: [],
+    skillsInstallations: [],
+    commandsInstallations: []
+  };
+
+  let aiTools = [];
+  let integrations = [];
+
+  // === STEP 1: Display Language ===
+  displayLanguage = await promptDisplayLanguage();
+  msg = t().commands.init; // Re-fetch after language change
+  const msgAfterLang = msg;
+
+  // === STEP 2: AI Tools Selection ===
+  aiTools = await promptAITools({
+    claudeCode: detected.aiTools.claudeCode || false,
+    cursor: detected.aiTools.cursor || false,
+    windsurf: detected.aiTools.windsurf || false,
+    cline: detected.aiTools.cline || false,
+    copilot: detected.aiTools.copilot || false,
+    antigravity: detected.aiTools.antigravity || false,
+    codex: detected.aiTools.codex || false,
+    opencode: detected.aiTools.opencode || false,
+    geminiCli: detected.aiTools.geminiCli || false
+  });
+
+  if (aiTools.length === 0) {
+    console.log();
+    console.log(chalk.yellow(msgAfterLang.noAiToolsSelected || 'No AI tools selected.'));
+    console.log(chalk.gray(msgAfterLang.noAiToolsExplanation || '  UDS provides development standards for AI coding assistants.'));
+    console.log(chalk.gray(msgAfterLang.noAiToolsExplanation2 || '  Without an AI tool, there is nothing to install.'));
+    console.log();
+    process.exit(0);
+  }
+
+  // === STEP 3: Handle AGENTS.md sharing ===
+  aiTools = handleAgentsMdSharing(aiTools);
+
+  const skillsSupportedTools = aiTools.filter(tool => {
+    const config = getAgentConfig(tool);
+    return config?.supportsSkills && config?.skills;
+  });
+  const hasSkillsTools = skillsSupportedTools.length > 0;
+
+  // === STEP 4: Skills Installation ===
+  if (hasSkillsTools) {
+    const { getMarketplaceSkillsInfo } = await import('../utils/github.js');
+    const marketplaceInfo = getMarketplaceSkillsInfo();
+
+    console.log();
+    console.log(chalk.cyan(msgAfterLang.skillsStatus));
+
+    let hasAnyExisting = false;
+
+    if (marketplaceInfo && marketplaceInfo.version) {
+      hasAnyExisting = true;
+      console.log(chalk.gray(`  ${msgAfterLang.skillsMarketplaceInstalled || 'Marketplace'}: v${marketplaceInfo.version}`));
+    }
+
+    for (const tool of skillsSupportedTools) {
+      const displayName = getAgentDisplayName(tool);
+      const projectInfo = getInstalledSkillsInfoForAgent(tool, 'project', projectPath);
+      const userInfo = getInstalledSkillsInfoForAgent(tool, 'user');
+
+      if (projectInfo || userInfo) {
+        hasAnyExisting = true;
+        if (projectInfo) {
+          console.log(chalk.gray(`  ${displayName} ${msgAfterLang.projectLevel}: v${projectInfo.version || 'unknown'}`));
+        }
+        if (userInfo) {
+          console.log(chalk.gray(`  ${displayName} ${msgAfterLang.userLevel}: v${userInfo.version || 'unknown'}`));
+        }
+      }
+    }
+
+    if (!hasAnyExisting) {
+      console.log(chalk.gray(`  ${msgAfterLang.noSkillsDetected}`));
+    }
+
+    const installations = await promptSkillsInstallLocation(aiTools);
+
+    if (installations.length > 0) {
+      const isMarketplace = installations.some(i => i.level === 'marketplace');
+
+      if (isMarketplace) {
+        skillsConfig = {
+          ...skillsConfig,
+          installed: true,
+          location: 'marketplace',
+          needsInstall: false,
+          updateTargets: [],
+          skillsInstallations: installations
+        };
+      } else {
+        skillsConfig = {
+          ...skillsConfig,
+          installed: true,
+          location: installations.length === 1 ? installations[0].level : 'multiple',
+          needsInstall: true,
+          updateTargets: installations.map(i => i.level),
+          skillsInstallations: installations
+        };
+      }
+    }
+
+    // === STEP 5: Slash Commands ===
+    const commandsAgents = await promptCommandsInstallation(aiTools);
+    if (commandsAgents.length > 0) {
+      skillsConfig.commandsInstallations = commandsAgents;
+    }
+  }
+
+  // === STEP 6: Standards Scope ===
+  const standardsScope = await promptStandardsScope(skillsConfig.installed);
+
+  // === STEP 7: Adoption Level ===
+  if (!level) {
+    level = await promptLevel();
+  }
+
+  // === STEP 8: Standards Format ===
+  if (!format) {
+    format = await promptFormat();
+  }
+
+  // === STEP 9: Standard Options ===
+  standardOptions = await promptStandardOptions(level, displayLanguage);
+
+  // === STEP 10: Language Extensions ===
+  if (!languages) {
+    languages = await promptLanguage(detected.languages) || [];
+  }
+
+  // === STEP 11: Framework Extensions ===
+  if (!frameworks) {
+    frameworks = await promptFramework(detected.frameworks) || [];
+  }
+
+  // === STEP 12: Integrations ===
+  integrations = [...aiTools];
+  const integrationConfigs = {};
+  
+  if (integrations.length > 0) {
+    const existingFiles = {};
+    for (const tool of integrations) {
+      existingFiles[tool] = integrationFileExists(tool, projectPath);
+    }
+
+    const hasAnyExisting = Object.values(existingFiles).some(v => v);
+    const toolNames = integrations.length === 1
+      ? integrations[0]
+      : `${integrations.slice(0, -1).join(', ')} & ${integrations[integrations.length - 1]}`;
+
+    const sharedConfig = await promptIntegrationConfig(toolNames, detected, hasAnyExisting);
+
+    if (sharedConfig.mergeStrategy !== 'keep') {
+      for (const tool of integrations) {
+        integrationConfigs[tool] = { ...sharedConfig, tool };
+      }
+    }
+  }
+
+  skillsConfig.integrationConfigs = integrationConfigs;
+  skillsConfig.standardsScope = standardsScope;
+
+  // === STEP 13: Content Mode ===
+  let contentMode = 'minimal';
+  if (aiTools.length > 0) {
+    contentMode = await promptContentMode();
+  }
+  skillsConfig.contentMode = contentMode;
+
+  // === STEP 14: Methodology ===
+  let methodology = null;
+  if (options.experimental) {
+    methodology = await promptMethodology();
+  }
+  skillsConfig.methodology = methodology;
+
+  return {
+    level,
+    languages,
+    frameworks,
+    displayLanguage,
+    format,
+    standardOptions,
+    skillsConfig,
+    aiTools,
+    integrations,
+    contentMode,
+    standardsScope
+  };
+}

package/src/hitl/checkpoint.js

@@ -0,0 +1,80 @@
+/**
+ * HITL Checkpoint
+ * Evaluates risk level against configuration to determine action.
+ */
+
+export class Checkpoint {
+  /**
+   * Evaluate an operation risk.
+   * @param {number} riskLevel - 0-4
+   * @param {Object} config - HITL configuration object
+   * @param {string} operation - Operation string (for pattern matching overrides)
+   * @returns {'approve' | 'prompt' | 'deny'} Action
+   */
+  evaluate(riskLevel, config, operation) {
+    const { 
+      threshold = 2, 
+      overrides = [], 
+      'always-prompt': alwaysPrompt = [], 
+      'never-prompt': neverPrompt = [] 
+    } = config;
+
+    // 1. Check explicit string matches (highest priority)
+    // Note: In real implementation, these would be regex patterns from config
+    // Simplified for now: assume config patterns are simple strings or regex strings
+    
+    // Check always-prompt
+    if (this._matchesAny(operation, alwaysPrompt)) {
+      return 'prompt';
+    }
+
+    // Check never-prompt
+    if (this._matchesAny(operation, neverPrompt)) {
+      return 'approve';
+    }
+
+    // 2. Check overrides (Pattern-based threshold adjustment)
+    let effectiveThreshold = threshold;
+    for (const override of overrides) {
+      if (this._matches(operation, override.pattern)) {
+        effectiveThreshold = override.threshold;
+        // Keep checking to find the most specific/last match? 
+        // For now, first match wins or last match wins? Usually last match wins in cascading.
+        // Let's assume the overrides list is ordered by priority.
+      }
+    }
+
+    // 3. Level 4 Restricted Safety Net
+    if (riskLevel >= 4) {
+      // Level 4 always requires explicit prompt or deny, never auto-approve based on standard threshold
+      // Unless explicitly overridden by a specific pattern with threshold 4+
+      return 'prompt'; 
+      // TODO: Should we return 'deny' by default for Level 4?
+      // Spec says: "Block unless override". "Block" usually means Deny.
+      // But for usability, maybe 'prompt' with a scary warning is better?
+      // Let's stick to 'prompt' for now, but the Manager should handle it carefully.
+    }
+
+    // 4. Standard Threshold Check
+    if (riskLevel < effectiveThreshold) {
+      return 'approve';
+    }
+
+    return 'prompt';
+  }
+
+  _matchesAny(text, patterns) {
+    if (!patterns || !Array.isArray(patterns)) return false;
+    return patterns.some(p => this._matches(text, p));
+  }
+
+  _matches(text, pattern) {
+    if (!text || !pattern) return false;
+    try {
+      // Simple includes check or Regex
+      return text.includes(pattern) || new RegExp(pattern).test(text);
+    } catch (e) {
+      return false;
+    }
+  }
+}

package/src/hitl/classifier.js

@@ -0,0 +1,54 @@
+/**
+ * HITL Risk Classifier
+ * Classifies operations into risk levels (0-4) based on patterns.
+ */
+
+export class RiskClassifier {
+  constructor() {
+    this.rules = [
+      // Level 4: Restricted (Destructive & Hard to Recover)
+      { pattern: /^rm\s+-(r|R|rf|fR)/, level: 4 },
+      { pattern: /drop\s+table/i, level: 4 },
+      { pattern: /git\s+push\s+.*--force/, level: 4 },
+      
+      // Level 3: Critical (Destructive or Security Sensitive)
+      { pattern: /^(delete|remove|unlink)/i, level: 3 },
+      { pattern: /^(deploy|publish|release)/i, level: 3 },
+      { pattern: /(auth|secret|password|token|key)/i, level: 3 },
+      { pattern: /^rm\s+/, level: 3 }, // Simple rm
+      
+      // Level 2: Elevated (Changes Config or Env)
+      { pattern: /^(npm|pip|yarn|pnpm)\s+install/, level: 2 },
+      { pattern: /^config\s+set/, level: 2 },
+      { pattern: /^chmod/, level: 2 },
+      
+      // Level 1: Standard (Modifies Files)
+      { pattern: /^(write|edit|modify|touch|mkdir)/i, level: 1 },
+      { pattern: /^git\s+commit/, level: 1 },
+      
+      // Level 0: Routine (Read-only)
+      { pattern: /^(read|cat|ls|grep|find|search)/i, level: 0 }
+    ];
+  }
+
+  /**
+   * Classify an operation string into a risk level.
+   * @param {string} operation - The operation description or command
+   * @returns {number} Risk level (0-4)
+   */
+  classify(operation) {
+    if (!operation || typeof operation !== 'string') {
+      return 1; // Default to Standard if unknown
+    }
+
+    const op = operation.trim();
+
+    for (const rule of this.rules) {
+      if (rule.pattern.test(op)) {
+        return rule.level;
+      }
+    }
+
+    return 1; // Default to Standard
+  }
+}