universal-dev-standards 4.1.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/agent-adapter.js

@@ -0,0 +1,320 @@
+/**
+ * Agent Adapter
+ *
+ * Provides cross-tool adaptation for AGENT.md definitions.
+ * Adapts agents for different execution modes based on AI tool capabilities.
+ *
+ * @version 1.0.0
+ */
+
+import { supportsTask, supportsAgents, getAgentConfig } from '../config/ai-agent-paths.js';
+
+/**
+ * Execution modes for agents
+ */
+export const ExecutionMode = {
+  TASK: 'task',         // Use Task tool to spawn independent subagent (Claude Code, OpenCode)
+  INLINE: 'inline',     // Inject agent content as context prefix (Cursor, Windsurf, etc.)
+  MANUAL: 'manual'      // Generate manual instructions (unsupported tools)
+};
+
+/**
+ * Determine the execution mode for an agent on a specific AI tool
+ * @param {string} aiTool - AI tool identifier
+ * @returns {string} Execution mode
+ */
+export function getExecutionMode(aiTool) {
+  if (supportsTask(aiTool)) {
+    return ExecutionMode.TASK;
+  }
+  if (supportsAgents(aiTool)) {
+    return ExecutionMode.INLINE;
+  }
+  return ExecutionMode.MANUAL;
+}
+
+/**
+ * Adapt agent configuration for a specific AI tool
+ * @param {Object} agentConfig - Parsed agent configuration
+ * @param {string} aiTool - Target AI tool identifier
+ * @returns {Object} Adapted configuration
+ */
+export function adaptAgentForTool(agentConfig, aiTool) {
+  const mode = getExecutionMode(aiTool);
+
+  switch (mode) {
+    case ExecutionMode.TASK:
+      return adaptForTaskMode(agentConfig, aiTool);
+    case ExecutionMode.INLINE:
+      return adaptForInlineMode(agentConfig, aiTool);
+    case ExecutionMode.MANUAL:
+      return adaptForManualMode(agentConfig, aiTool);
+    default:
+      return { mode: ExecutionMode.MANUAL, error: `Unknown mode for ${aiTool}` };
+  }
+}
+
+/**
+ * Adapt agent for Task tool execution mode
+ * @param {Object} agentConfig - Agent configuration
+ * @param {string} aiTool - AI tool identifier
+ * @returns {Object} Task mode configuration
+ */
+function adaptForTaskMode(agentConfig, aiTool) {
+  const taskConfig = {
+    subagent_type: agentConfig.name || 'general-purpose',
+    description: truncateDescription(agentConfig.description),
+    model: agentConfig.model || 'sonnet',
+  };
+
+  // Map allowed/disallowed tools to Task tool format
+  if (agentConfig['allowed-tools']) {
+    taskConfig.allowedTools = parseToolList(agentConfig['allowed-tools']);
+  }
+  if (agentConfig['disallowed-tools']) {
+    taskConfig.disallowedTools = parseToolList(agentConfig['disallowed-tools']);
+  }
+
+  // Add skill dependencies as context
+  if (agentConfig.skills && agentConfig.skills.length > 0) {
+    taskConfig.skillDependencies = agentConfig.skills;
+  }
+
+  return {
+    mode: ExecutionMode.TASK,
+    aiTool,
+    taskConfig,
+    triggers: agentConfig.triggers || {}
+  };
+}
+
+/**
+ * Adapt agent for inline context injection mode
+ * @param {Object} agentConfig - Agent configuration
+ * @param {string} aiTool - AI tool identifier
+ * @returns {Object} Inline mode configuration
+ */
+function adaptForInlineMode(agentConfig, aiTool) {
+  // Generate context prefix for tools that don't support Task tool
+  const contextPrefix = generateInlineContextPrefix(agentConfig);
+
+  return {
+    mode: ExecutionMode.INLINE,
+    aiTool,
+    contextPrefix,
+    triggers: agentConfig.triggers || {},
+    note: 'This tool does not support subagent execution. Agent will be injected as context.'
+  };
+}
+
+/**
+ * Adapt agent for manual instruction mode
+ * @param {Object} agentConfig - Agent configuration
+ * @param {string} aiTool - AI tool identifier
+ * @returns {Object} Manual mode configuration
+ */
+function adaptForManualMode(agentConfig, aiTool) {
+  const instructions = generateManualInstructions(agentConfig);
+
+  return {
+    mode: ExecutionMode.MANUAL,
+    aiTool,
+    instructions,
+    note: 'This tool does not support agents. Use these instructions manually.'
+  };
+}
+
+/**
+ * Generate inline context prefix for injection mode
+ * @param {Object} agentConfig - Agent configuration
+ * @returns {string} Context prefix
+ */
+function generateInlineContextPrefix(agentConfig) {
+  const lines = [
+    `<!-- UDS Agent: ${agentConfig.name} -->`,
+    `<!-- Role: ${agentConfig.role || 'specialist'} -->`,
+    ''
+  ];
+
+  if (agentConfig.expertise && agentConfig.expertise.length > 0) {
+    lines.push(`## Agent Expertise: ${agentConfig.expertise.join(', ')}`);
+    lines.push('');
+  }
+
+  if (agentConfig.description) {
+    lines.push('## Agent Purpose');
+    lines.push(cleanDescription(agentConfig.description));
+    lines.push('');
+  }
+
+  // Add tool permission hints
+  if (agentConfig['allowed-tools']) {
+    const tools = parseToolList(agentConfig['allowed-tools']);
+    lines.push(`## Allowed Operations: ${tools.join(', ')}`);
+  }
+  if (agentConfig['disallowed-tools']) {
+    const tools = parseToolList(agentConfig['disallowed-tools']);
+    lines.push(`## Restricted Operations: ${tools.join(', ')}`);
+  }
+
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate manual instructions for unsupported tools
+ * @param {Object} agentConfig - Agent configuration
+ * @returns {string} Manual instructions
+ */
+function generateManualInstructions(agentConfig) {
+  const lines = [
+    `# ${agentConfig.name} Agent Instructions`,
+    '',
+    '## How to Use This Agent Manually',
+    '',
+    '1. Copy the agent content below into your AI assistant\'s context',
+    '2. Provide your task after the agent instructions',
+    '3. The AI will act according to the agent\'s role and expertise',
+    '',
+    '## Agent Information',
+    '',
+    `- **Name**: ${agentConfig.name}`,
+    `- **Role**: ${agentConfig.role || 'specialist'}`,
+  ];
+
+  if (agentConfig.expertise) {
+    lines.push(`- **Expertise**: ${agentConfig.expertise.join(', ')}`);
+  }
+
+  if (agentConfig.description) {
+    lines.push('');
+    lines.push('## Purpose');
+    lines.push(cleanDescription(agentConfig.description));
+  }
+
+  if (agentConfig.triggers && agentConfig.triggers.keywords) {
+    lines.push('');
+    lines.push('## Trigger Keywords');
+    lines.push(`Use this agent when: ${agentConfig.triggers.keywords.join(', ')}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Parse tool list from various formats
+ * @param {string|string[]} tools - Tool list
+ * @returns {string[]} Normalized tool list
+ */
+function parseToolList(tools) {
+  if (Array.isArray(tools)) {
+    return tools;
+  }
+  if (typeof tools === 'string') {
+    // Handle comma-separated or bracket-enclosed format
+    return tools
+      .replace(/^\[|\]$/g, '')
+      .split(',')
+      .map(t => t.trim())
+      .filter(t => t.length > 0);
+  }
+  return [];
+}
+
+/**
+ * Truncate description for Task tool (short description)
+ * @param {string} description - Full description
+ * @returns {string} Truncated description (max 50 chars)
+ */
+function truncateDescription(description) {
+  if (!description) return 'UDS Agent';
+  const cleaned = cleanDescription(description);
+  const firstLine = cleaned.split('\n')[0].trim();
+  if (firstLine.length <= 50) return firstLine;
+  return firstLine.substring(0, 47) + '...';
+}
+
+/**
+ * Clean description text
+ * @param {string} description - Description text
+ * @returns {string} Cleaned description
+ */
+function cleanDescription(description) {
+  if (!description) return '';
+  return description
+    .replace(/^\|?\s*/, '')  // Remove leading pipe and spaces (YAML multiline)
+    .replace(/\s+/g, ' ')     // Normalize whitespace
+    .trim();
+}
+
+/**
+ * Get all supported AI tools and their execution modes
+ * @returns {Object[]} Array of tool info objects
+ */
+export function getAllToolsWithModes() {
+  const tools = [
+    'claude-code', 'opencode', 'cursor', 'cline',
+    'roo-code', 'codex', 'copilot', 'windsurf', 'gemini-cli'
+  ];
+
+  return tools.map(tool => {
+    const config = getAgentConfig(tool);
+    return {
+      id: tool,
+      name: config?.name || tool,
+      mode: getExecutionMode(tool),
+      supportsTask: supportsTask(tool),
+      supportsAgents: supportsAgents(tool)
+    };
+  });
+}
+
+/**
+ * Check if an agent is compatible with a specific AI tool
+ * @param {Object} agentConfig - Agent configuration
+ * @param {string} aiTool - AI tool identifier
+ * @returns {Object} Compatibility info
+ */
+export function checkAgentToolCompatibility(agentConfig, aiTool) {
+  const mode = getExecutionMode(aiTool);
+
+  const result = {
+    compatible: true,
+    mode,
+    warnings: [],
+    features: {
+      taskExecution: mode === ExecutionMode.TASK,
+      toolPermissions: mode === ExecutionMode.TASK,
+      skillDependencies: mode === ExecutionMode.TASK,
+      triggers: true
+    }
+  };
+
+  // Check tool permissions compatibility
+  if (agentConfig['allowed-tools'] && mode !== ExecutionMode.TASK) {
+    result.warnings.push('Tool permissions will be ignored (inline/manual mode)');
+  }
+
+  // Check model preference compatibility
+  if (agentConfig.model && mode !== ExecutionMode.TASK) {
+    result.warnings.push('Model preference will be ignored (inline/manual mode)');
+  }
+
+  // Check skill dependencies
+  if (agentConfig.skills && agentConfig.skills.length > 0 && mode !== ExecutionMode.TASK) {
+    result.warnings.push('Skill dependencies require manual loading (inline/manual mode)');
+  }
+
+  return result;
+}
+
+export default {
+  ExecutionMode,
+  getExecutionMode,
+  adaptAgentForTool,
+  getAllToolsWithModes,
+  checkAgentToolCompatibility
+};