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

package/src/prompts/integrations.js

@@ -103,6 +103,7 @@ export async function promptIntegrationMode() {
       type: 'list',
       name: 'mode',
       message: msg.question,
+      suffix: ' ',
       choices: [
         {
           name: `${chalk.green('Default')} ${chalk.gray(`(${t().recommended})`)} - ${msg.choices.default}`,
@@ -149,6 +150,8 @@ export async function promptRuleCategories(_detected = {}) {
       type: 'checkbox',
       name: 'categories',
       message: msg.question,
+      suffix: ' ',
+      instructions: false,
       choices,
       validate: (answer) => {
         if (answer.length === 0) {
@@ -199,6 +202,8 @@ export async function promptLanguageRules(detected = {}) {
       type: 'checkbox',
       name: 'languages',
       message: msg.question,
+      suffix: ' ',
+      instructions: false,
       choices
     }
   ]);
@@ -223,6 +228,7 @@ export async function promptExclusions() {
       type: 'confirm',
       name: 'hasExclusions',
       message: msg.question,
+      suffix: ' ',
       default: false
     }
   ]);
@@ -236,6 +242,7 @@ export async function promptExclusions() {
       type: 'input',
       name: 'exclusions',
       message: msg.inputPrompt,
+      suffix: ' ',
       filter: (input) => input.split(',').map(s => s.trim()).filter(s => s.length > 0)
     }
   ]);
@@ -260,6 +267,7 @@ export async function promptCustomRules() {
       type: 'confirm',
       name: 'hasCustomRules',
       message: msg.question,
+      suffix: ' ',
       default: false
     }
   ]);
@@ -277,6 +285,7 @@ export async function promptCustomRules() {
         type: 'input',
         name: 'rule',
         message: msg.inputPrompt,
+        suffix: ' '
       }
     ]);
 
@@ -308,6 +317,7 @@ export async function promptMergeStrategy(toolName) {
       type: 'list',
       name: 'strategy',
       message: msg.question,
+      suffix: ' ',
       choices: [
         {
           name: `${chalk.green('Append')} ${chalk.gray(`(${t().recommended})`)} - ${msg.choices.append}`,
@@ -350,6 +360,7 @@ export async function promptDetailLevel() {
       type: 'list',
       name: 'level',
       message: msg.question,
+      suffix: ' ',
       choices: [
         {
           name: `${chalk.gray(msg.labels.minimal)} - ${msg.choices.minimal}`,
@@ -383,6 +394,7 @@ export async function promptRuleLanguage() {
       type: 'list',
       name: 'language',
       message: msg.question,
+      suffix: ' ',
       choices: [
         {
           name: `${chalk.green(msg.choices.en)} ${chalk.gray(`(${t().recommended})`)}`,
@@ -437,7 +449,7 @@ export async function promptIntegrationConfig(tool, detected, existingRulesFound
     customRules: [],
     mergeStrategy: null,
     detailLevel: 'standard',
-    language: 'en'
+    language: null
   };
 
   // If existing rules found, ask about merge strategy first

package/src/schemas/standard.schema.json

@@ -0,0 +1,117 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "UDS Standard Definition (v2)",
+  "description": "Schema for Universal Development Standards .ai.yaml files, supporting Dual-Layer Architecture.",
+  "type": "object",
+  "required": ["standard"],
+  "properties": {
+    "standard": {
+      "type": "object",
+      "description": "The Imagination Layer: Human-readable and AI-promptable guidelines.",
+      "required": ["id", "name", "description", "guidelines"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Unique identifier for the standard (e.g., STR-001)."
+        },
+        "name": {
+          "type": "string",
+          "description": "Display name of the standard."
+        },
+        "description": {
+          "type": "string",
+          "description": "Brief description for AI context."
+        },
+        "guidelines": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "List of semantic guidelines."
+        }
+      }
+    },
+    "physical_spec": {
+      "type": "object",
+      "description": "The Physical Layer: Machine-readable constraints and validators.",
+      "required": ["type"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["filesystem_schema", "json_schema", "regex_validator", "custom_script", "script_file"],
+          "description": "Type of the physical constraint."
+        },
+        "schema": {
+          "type": "object",
+          "description": "The actual schema definition (e.g., directory structure, JSON schema)."
+        },
+        "validator": {
+          "type": "object",
+          "description": "Configuration for the validation command.",
+          "properties": {
+            "command": {
+              "type": "string",
+              "description": "Shell command to run validation (use placeholders like {target})."
+            },
+            "script_path": {
+              "type": "string",
+              "description": "Path to a JS/TS script file that performs validation."
+            },
+            "rule": {
+              "type": "string",
+              "description": "Validation rule identifier."
+            }
+          }
+        },
+        "simulator": {
+          "type": "object",
+          "description": "Configuration for the simulation command (predictive validation).",
+          "properties": {
+            "command": { 
+              "type": "string", 
+              "description": "Command to run simulation. Use {input} placeholder." 
+            },
+            "script_path": {
+              "type": "string",
+              "description": "Path to a JS/TS script file that performs simulation."
+            },
+            "type": { 
+              "type": "string", 
+              "enum": ["command", "script", "script_file"], 
+              "default": "command" 
+            }
+          },
+          "required": ["command"]
+        },
+        "fixer": {
+          "type": "object",
+          "description": "Configuration for auto-fixing violations.",
+          "properties": {
+            "type": { 
+              "type": "string", 
+              "enum": ["command", "copy_template", "script_file"], 
+              "description": "Type of fix action" 
+            },
+            "command": { 
+              "type": "string", 
+              "description": "Command to run for fixing (for type=command)" 
+            },
+            "script_path": {
+              "type": "string",
+              "description": "Path to a JS/TS script file that performs fixing (for type=script_file)."
+            },
+            "template_file": { 
+              "type": "string", 
+              "description": "Path to template file (relative to .standards/templates or absolute)" 
+            },
+            "destination": { 
+              "type": "string", 
+              "description": "Destination path (relative to project root)" 
+            }
+          },
+          "required": ["type"]
+        }
+      }
+    }
+  }
+}

package/src/utils/agents-installer.js

@@ -29,12 +29,12 @@ const BUNDLED_DIR = join(CLI_ROOT, 'bundled');
  * @returns {string} Path to agents source directory
  */
 function getAgentsSourceDir() {
-  const bundledPath = join(BUNDLED_DIR, 'skills', 'claude-code', 'agents');
+  const bundledPath = join(BUNDLED_DIR, 'skills', 'agents');
   if (existsSync(bundledPath)) {
     return bundledPath;
   }
   // Development environment fallback
-  return join(CLI_ROOT, '..', 'skills', 'claude-code', 'agents');
+  return join(CLI_ROOT, '..', 'skills', 'agents');
 }
 
 const AGENTS_LOCAL_DIR = getAgentsSourceDir();

package/src/utils/config-loader.js

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import yaml from 'js-yaml';
+
+export class ConfigLoader {
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+    this.globalPath = path.join(os.homedir(), '.udsrc');
+    this.projectPath = path.join(this.cwd, '.uds', 'config.yaml');
+  }
+
+  /**
+   * Load global configuration from ~/.udsrc
+   * @returns {Object}
+   */
+  loadGlobal() {
+    return this._loadFile(this.globalPath);
+  }
+
+  /**
+   * Load project configuration from ./.uds/config.yaml
+   * @returns {Object}
+   */
+  loadProject() {
+    return this._loadFile(this.projectPath);
+  }
+
+  /**
+   * Internal helper to load and parse YAML/JSON
+   * @private
+   */
+  _loadFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return {};
+    }
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      // js-yaml handles both JSON and YAML
+      return yaml.load(content) || {};
+    } catch (error) {
+      console.warn(`Warning: Failed to load config at ${filePath}: ${error.message}`);
+      return {};
+    }
+  }
+}

package/src/utils/config-manager.js

@@ -0,0 +1,108 @@
+import { ConfigLoader } from './config-loader.js';
+import { ConfigMerger } from './config-merger.js';
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+export class ConfigManager {
+  constructor(cwd = process.cwd()) {
+    this.loader = new ConfigLoader(cwd);
+    this.config = {};
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize and merge all configurations
+   */
+  init() {
+    const globalConfig = this.loader.loadGlobal();
+    const projectConfig = this.loader.loadProject();
+
+    // Built-in defaults
+    const defaults = {
+      ui: {
+        language: 'en',
+        emoji: true
+      },
+      hitl: {
+        threshold: 2
+      },
+      'vibe-coding': {
+        enabled: false
+      }
+    };
+
+    // Merge: Defaults <- Global <- Project
+    this.config = ConfigMerger.merge(defaults, globalConfig);
+    this.config = ConfigMerger.merge(this.config, projectConfig);
+    
+    this.initialized = true;
+    return this.config;
+  }
+
+  /**
+   * Get a configuration value using dot notation
+   * @param {string} keyPath - e.g. 'ui.language'
+   * @param {*} defaultValue
+   */
+  get(keyPath, defaultValue) {
+    if (!this.initialized) this.init();
+
+    const parts = keyPath.split('.');
+    let current = this.config;
+
+    for (const part of parts) {
+      if (current === null || typeof current !== 'object' || !(part in current)) {
+        return defaultValue;
+      }
+      current = current[part];
+    }
+
+    return current !== undefined ? current : defaultValue;
+  }
+
+  /**
+   * Set a configuration value and persist to disk
+   * @param {string} keyPath 
+   * @param {*} value 
+   * @param {string} scope - 'global' or 'project'
+   */
+  set(keyPath, value, scope = 'project') {
+    if (!this.initialized) this.init();
+
+    const parts = keyPath.split('.');
+    const filePath = scope === 'global' ? this.loader.globalPath : this.loader.projectPath;
+    
+    // Load existing file content to preserve other settings
+    let fileContent = {};
+    if (fs.existsSync(filePath)) {
+      try {
+        fileContent = yaml.load(fs.readFileSync(filePath, 'utf8')) || {};
+      } catch (e) {
+        fileContent = {};
+      }
+    }
+
+    // Update value in fileContent object
+    let current = fileContent;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!(part in current)) current[part] = {};
+      current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+
+    // Persist to disk
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, yaml.dump(fileContent), 'utf8');
+
+    // Re-initialize to update in-memory config
+    this.init();
+  }
+}
+
+// Singleton instance for the CLI
+export const config = new ConfigManager();

package/src/utils/config-merger.js

@@ -0,0 +1,47 @@
+/**
+ * Configuration Merger for UDS
+ * Handles deep merging of configuration objects with support for special strategies.
+ */
+
+export class ConfigMerger {
+  /**
+   * Deep merge two objects.
+   * @param {Object} base - The base object (lower priority)
+   * @param {Object} override - The override object (higher priority)
+   * @returns {Object} - The merged object
+   */
+  static merge(base, override) {
+    if (!base) return override || {};
+    if (!override) return base || {};
+
+    const result = { ...base };
+
+    for (const key in override) {
+      const value = override[key];
+
+      // Handle arrays
+      if (Array.isArray(value)) {
+        // Special strategy: $append
+        if (value.length > 0 && typeof value[0] === 'object' && value[0].$append) {
+          const itemsToAppend = value[0].$append;
+          result[key] = Array.isArray(base[key]) ? [...base[key], ...itemsToAppend] : itemsToAppend;
+        } else {
+          // Default: Replace array
+          result[key] = value;
+        }
+        continue;
+      }
+
+      // Handle nested objects
+      if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        result[key] = this.merge(base[key] || {}, value);
+        continue;
+      }
+
+      // Handle primitives
+      result[key] = value;
+    }
+
+    return result;
+  }
+}

package/src/utils/github.js

@@ -19,7 +19,7 @@ export {
 } from '../config/ai-agent-paths.js';
 
 const GITHUB_RAW_BASE = 'https://raw.githubusercontent.com/AsiaOstrich/universal-dev-standards/main';
-const SKILLS_RAW_BASE = 'https://raw.githubusercontent.com/AsiaOstrich/universal-dev-standards/main/skills/claude-code';
+const SKILLS_RAW_BASE = 'https://raw.githubusercontent.com/AsiaOstrich/universal-dev-standards/main/skills';
 
 // Get the CLI package root directory
 const __filename = fileURLToPath(import.meta.url);
@@ -545,30 +545,34 @@ export function getMarketplaceSkillsInfo() {
     const info = pluginInfo[0];
     let version = info.version || 'unknown';
 
-    // installed_plugins.json may have stale version info
-    // Check the actual cache directory for the latest installed version
+    // installed_plugins.json may have stale records - plugin may be uninstalled
+    // but JSON record not cleaned up. Verify cache directory actually exists.
     // pluginKey format: "universal-dev-standards@asia-ostrich"
     const parts = pluginKey.split('@');
     if (parts.length === 2) {
       const [pluginName, marketplace] = parts;
       const cacheDir = join(homedir(), '.claude', 'plugins', 'cache', marketplace, pluginName);
 
-      if (existsSync(cacheDir)) {
-        try {
-          const versions = readdirSync(cacheDir)
-            .filter(name => name.match(/^\d+\.\d+\.\d+/));
-
-          if (versions.length > 0) {
-            // Sort versions and get the latest
-            versions.sort(compareVersionsForSort);
-            const latestVersion = versions[versions.length - 1];
-            if (latestVersion && latestVersion !== version) {
-              version = latestVersion;
-            }
+      // Fix: If cache directory doesn't exist, plugin was uninstalled but record remains
+      // Return null to indicate plugin is not actually installed
+      if (!existsSync(cacheDir)) {
+        return null;
+      }
+
+      try {
+        const versions = readdirSync(cacheDir)
+          .filter(name => name.match(/^\d+\.\d+\.\d+/));
+
+        if (versions.length > 0) {
+          // Sort versions and get the latest
+          versions.sort(compareVersionsForSort);
+          const latestVersion = versions[versions.length - 1];
+          if (latestVersion && latestVersion !== version) {
+            version = latestVersion;
           }
-        } catch {
-          // Ignore errors reading cache directory
         }
+      } catch {
+        // Ignore errors reading cache directory
       }
     }
 
@@ -620,7 +624,7 @@ export async function downloadSkillToLocation(skillName, skillFiles, targetLocat
 
     try {
       // For remote download, we need to extract just the skill-relative path
-      // skillFiles paths are like: skills/claude-code/ai-collaboration-standards/SKILL.md
+      // skillFiles paths are like: skills/ai-collaboration-standards/SKILL.md
       // We need just: ai-collaboration-standards/SKILL.md
       const relativePath = filePath.replace(/^skills\/claude-code\//, '');
       const content = await downloadFromSkillsRepo(relativePath);

package/src/utils/inquirer-patch.js

@@ -0,0 +1,98 @@
+/**
+ * Inquirer Checkbox Patch
+ *
+ * Monkey-patches inquirer's CheckboxPrompt to properly support the
+ * `instructions: false` option, which is ignored in the default implementation.
+ *
+ * Problem: inquirer uses `this.dontShowHints` internally but only sets it to
+ * true in `onEnd()`. The `instructions` option in the question config is
+ * completely ignored.
+ *
+ * Solution: Extend CheckboxPrompt to respect `instructions: false` from the
+ * question config by setting `dontShowHints = true` in the constructor.
+ *
+ * @see https://github.com/SBoudrias/Inquirer.js/blob/master/packages/inquirer/lib/prompts/checkbox.js
+ */
+
+import inquirer from 'inquirer';
+
+// Flag to track if patch has been applied
+let patchApplied = false;
+
+/**
+ * Patch inquirer checkbox to support translated instructions
+ *
+ * After calling this function, any checkbox prompt with `instructions: false`
+ * will properly hide the default English hint text:
+ * "(Press <space> to select, <a> to toggle all, <i> to invert selection, and <enter> to proceed)"
+ *
+ * Usage:
+ * ```javascript
+ * import { patchCheckboxInstructions } from '../utils/inquirer-patch.js';
+ *
+ * // Call once at module load
+ * patchCheckboxInstructions();
+ *
+ * // Now checkbox prompts respect instructions: false
+ * const { items } = await inquirer.prompt([{
+ *   type: 'checkbox',
+ *   name: 'items',
+ *   message: 'Select items:',
+ *   instructions: false,  // This now works!
+ *   choices: [...]
+ * }]);
+ * ```
+ */
+export function patchCheckboxInstructions() {
+  // Avoid applying patch multiple times
+  if (patchApplied) {
+    return;
+  }
+
+  // Get the original CheckboxPrompt class
+  const originalCheckbox = inquirer.prompt.prompts?.checkbox;
+
+  // If checkbox prompt is not available, skip patching silently
+  // This is expected in test environments where inquirer is mocked
+  if (!originalCheckbox) {
+    return;
+  }
+
+  /**
+   * Patched CheckboxPrompt that respects the `instructions` option
+   */
+  class PatchedCheckboxPrompt extends originalCheckbox {
+    constructor(questions, rl, answers) {
+      super(questions, rl, answers);
+
+      // If instructions: false is set, hide the default hint
+      // This is the key fix - the original implementation ignores this option
+      if (this.opt.instructions === false) {
+        this.dontShowHints = true;
+      }
+    }
+  }
+
+  // Register the patched prompt
+  inquirer.registerPrompt('checkbox', PatchedCheckboxPrompt);
+
+  patchApplied = true;
+}
+
+/**
+ * Check if the patch has been applied
+ * @returns {boolean} True if patch has been applied
+ */
+export function isPatchApplied() {
+  return patchApplied;
+}
+
+/**
+ * Reset patch state (mainly for testing)
+ * Note: This does not restore the original checkbox prompt
+ */
+export function resetPatchState() {
+  patchApplied = false;
+}
+
+export default patchCheckboxInstructions;