@yahoo/uds 3.46.2 → 3.48.0

package/cli/commands/editor-rules.ts

@@ -0,0 +1,159 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import type { Props } from 'bluebun';
+import { blue, green, print, red, yellow } from 'bluebun';
+
+import type { EditorConfig } from '../rules/config';
+import { getAvailableEditors, getEditorConfig, getRuleContent } from '../rules/config';
+import { trackEvent } from '../utils/analytics';
+import type { EditorRulesOptions } from '../utils/types';
+
+interface EditorRulesProps extends Props {
+  options: EditorRulesOptions;
+}
+
+export default {
+  name: 'editor-rules',
+  description: '🎯 Generate editor rules for various code editors and AI tools',
+  alias: ['rules', 'editor'],
+  options: {
+    force: {
+      type: 'boolean',
+      description: 'Force overwrite existing rules directory',
+      alias: 'f',
+    },
+    output: {
+      type: 'string',
+      description: 'Output directory (defaults to workspace root)',
+      alias: 'o',
+    },
+    editor: {
+      type: 'string',
+      description: 'Specific editor or AI tool to generate rules for',
+      alias: 'e',
+    },
+  },
+  run: async ({ options }: EditorRulesProps) => {
+    // Check for help flag manually since bluebun help handling seems to have issues
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+      print(blue('🎯 UDS Editor Rules Command'));
+      print('');
+      print(green('Description: Generate editor rules for various code editors and AI tools'));
+      print('');
+      print(yellow('Options:'));
+      print('  --force, -f     Force overwrite existing rules directory');
+      print('  --output, -o    Output directory (defaults to workspace root)');
+      print('  --editor, -e    Specific editor/tool (defaults to all)');
+      print('');
+      print(blue('Available editors/tools:'));
+      const editors = getAvailableEditors();
+      for (const editor of editors) {
+        const config = getEditorConfig(editor);
+        if (config) {
+          print(`  • ${editor}: ${config.description}`);
+        }
+      }
+      print('');
+      print(blue('Examples:'));
+      print('  uds editor-rules                    # Generate all rules in current directory');
+      print('  uds editor-rules --editor cursor    # Generate only Cursor rules');
+      print('  uds editor-rules --output /path     # Generate rules in specific directory');
+      print('  uds editor-rules --force            # Force overwrite existing rules');
+      print('');
+      print(green('What it generates:'));
+      print('  • Cursor Rules (.cursor/uds/)');
+      return;
+    }
+
+    try {
+      const outputDir = options.output || process.cwd();
+      const selectedEditor = options.editor?.toLowerCase();
+
+      print(blue(`📁 Generating editor rules in: ${outputDir}`));
+
+      if (selectedEditor) {
+        // Generate rules for specific editor
+        const editorConfig = getEditorConfig(selectedEditor);
+        if (!editorConfig) {
+          print(red(`❌ Unknown editor: ${selectedEditor}`));
+          print(yellow('Available editors:'));
+          const editors = getAvailableEditors();
+          for (const editor of editors) {
+            const config = getEditorConfig(editor);
+            if (config) {
+              print(`  • ${editor}: ${config.description}`);
+            }
+          }
+          return;
+        }
+
+        await generateEditorRules(outputDir, selectedEditor, editorConfig, options.force);
+      } else {
+        // Generate rules for all editors
+        const editors = getAvailableEditors();
+        for (const editor of editors) {
+          const editorConfig = getEditorConfig(editor);
+          if (editorConfig) {
+            await generateEditorRules(outputDir, editor, editorConfig, options.force);
+          }
+        }
+      }
+
+      print(green('🎉 Editor rules generated successfully!'));
+      print(blue('📝 Rules are now available for your development environment'));
+
+      await trackEvent('editor_rules_generated', {
+        output_dir: outputDir,
+        force: options.force || false,
+        editor: selectedEditor || 'all',
+      });
+    } catch (error) {
+      print(red(`❌ Error generating editor rules: ${error}`));
+      process.exitCode = 1;
+    }
+  },
+};
+
+async function generateEditorRules(
+  outputDir: string,
+  editorName: string,
+  editorConfig: EditorConfig,
+  force: boolean = false,
+) {
+  print(blue(`\n🔧 Generating ${editorConfig.name} rules...`));
+
+  for (const rule of editorConfig.rules) {
+    print(yellow(`  📝 ${rule.name}: ${rule.description}`));
+
+    for (const file of rule.files) {
+      const targetPath = join(outputDir, file.target);
+      const targetDir = join(targetPath, '..');
+
+      // Create target directory if it doesn't exist
+      if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+      }
+
+      // Check if file exists and handle force flag
+      if (existsSync(targetPath)) {
+        if (force) {
+          print(yellow(`    🗑️  Overwriting: ${file.target}`));
+        } else {
+          print(red(`    ❌ File already exists: ${file.target}`));
+          print(yellow('    Use --force to overwrite existing files'));
+          continue;
+        }
+      }
+
+      try {
+        // Read and write the rule file
+        const content = getRuleContent(file.source);
+        writeFileSync(targetPath, content);
+        print(green(`    ✅ Created: ${file.target}`));
+      } catch (error) {
+        print(red(`    ❌ Error creating ${file.target}: ${error}`));
+      }
+    }
+  }
+}

package/cli/rules/config.ts

@@ -0,0 +1,73 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface RuleConfig {
+  name: string;
+  description: string;
+  files: Array<{
+    source: string;
+    target: string;
+    type: 'file' | 'directory';
+  }>;
+}
+
+export interface EditorConfig {
+  name: string;
+  description: string;
+  rules: RuleConfig[];
+}
+
+export const EDITOR_CONFIGS: Record<string, EditorConfig> = {
+  cursor: {
+    name: 'Cursor',
+    description: 'AI-powered coding assistant rules for UDS development',
+    rules: [
+      {
+        name: 'UDS Components',
+        description: 'Component development guidelines and patterns',
+        files: [
+          {
+            source: 'cursor/uds/components.mdc',
+            target: '.cursor/rules/uds/components.mdc',
+            type: 'file',
+          },
+        ],
+      },
+      {
+        name: 'UDS Tailwind',
+        description: 'Tailwind CSS configuration and setup guidelines',
+        files: [
+          {
+            source: 'cursor/uds/tailwind.mdc',
+            target: '.cursor/rules/uds/tailwind.mdc',
+            type: 'file',
+          },
+        ],
+      },
+      {
+        name: 'UDS Icons',
+        description: 'Icon usage and documentation guidelines',
+        files: [
+          {
+            source: 'cursor/uds/icons.mdc',
+            target: '.cursor/rules/uds/icons.mdc',
+            type: 'file',
+          },
+        ],
+      },
+    ],
+  },
+};
+
+export function getAvailableEditors(): string[] {
+  return Object.keys(EDITOR_CONFIGS);
+}
+
+export function getEditorConfig(editor: string): EditorConfig | undefined {
+  return EDITOR_CONFIGS[editor];
+}
+
+export function getRuleContent(rulePath: string): string {
+  const fullPath = join(__dirname, rulePath);
+  return readFileSync(fullPath, 'utf-8');
+}

package/cli/rules/cursor/uds/components.mdc

@@ -0,0 +1,25 @@
+---
+description: UDS components
+globs:
+alwaysApply: true
+---
+
+- Always fetch components type definition using the UDS mcp server
+- Always fetch the possible components from uds using the UDS mcp server
+- Anytime you are about to use a component, fetch the type definition
+- Anytime you are about to use a component, fetch the component documentation examples
+- Anytime you have to create a component, make sure you are using UDS components
+- Never create already existing UDS components from scratch
+- Make sure there are no type errors when you create new components
+- Always use UDS UI library components instead of raw HTML tags.
+- Only create custom components when UDS doesn't provide the needed functionality
+- `<Box>` has `display = 'flex'` by default - use `<VStack>` for vertical stacking, `<HStack>` for horizontal, or `<div>` for simple containers
+- Use `<Text>` instead of `<p>`, `<span>`, `<h1>`-`<h6>`
+- Use `<Button>` instead of `<button>`
+- Use `<Input>` instead of `<input>`
+- Use `<Checkbox>` instead of `<input type="checkbox">`
+- Use `<Radio>` instead of `<input type="radio">`
+- Use `<Switch>` instead of custom toggle components
+- Use `<Link>` instead of `<a>`
+- Use `<Icon>` instead of SVG elements
+- Fix all lint errors before completing the task

package/cli/rules/cursor/uds/icons.mdc

@@ -0,0 +1,8 @@
+---
+description: UDS Icons
+globs:
+alwaysApply: true
+---
+
+- Anytime you have to use an icon in a UDS component or use UDS icons outside UDS components, fetch Icon documentation for more context from the MCP server
+- Always check what icons are available in UDS through the MCP server

package/cli/rules/cursor/uds/tailwind.mdc

@@ -0,0 +1,9 @@
+---
+description: UDS config
+globs:
+alwaysApply: true
+---
+
+- Never create a UDS config manually
+- If `uds.config.ts` or `uds.config.js` is not present at the root of the project, ask the user to create it using UDS CLI sync command
+- Make sure that tailwind configuration has the UDS tailwind plugin

package/cli/utils/types.ts

@@ -19,3 +19,12 @@ export type SyncOptions = {
   /** The version of the CLI */
   version: string;
 };
+
+export type EditorRulesOptions = {
+  /** Force overwrite existing rules directory */
+  force?: boolean;
+  /** Output directory (defaults to workspace root) */
+  output?: string;
+  /** Specific editor or AI tool to generate rules for */
+  editor?: string;
+};