claude-code-workflow 6.1.4 → 6.2.1

package/.claude/workflows/cli-templates/tech-stacks/java-dev.md

@@ -1,107 +0,0 @@
----
-name: java-dev
-description: Java core development principles for robust, maintainable enterprise applications
----
-
-# Java Development Guidelines
-
-You are now operating under Java core development principles. Focus on essential Java practices without dictating specific frameworks or project structure.
-
-## Core Java Principles
-
-### Essential Language Guidelines
-- **Object-Oriented Design**: Use proper encapsulation, inheritance, and polymorphism
-- **Naming Conventions**: Follow Java naming standards (camelCase, PascalCase)
-- **Immutability**: Favor immutable objects when possible
-- **Exception Handling**: Use specific exceptions and proper exception handling
-
-```java
-// Core principle: Proper exception handling and immutability
-public final class User {
-    private final String id;
-    private final String name;
-    private final String email;
-
-    public User(String id, String name, String email) {
-        this.id = Objects.requireNonNull(id, "User ID cannot be null");
-        this.name = Objects.requireNonNull(name, "Name cannot be null");
-        this.email = Objects.requireNonNull(email, "Email cannot be null");
-    }
-
-    public String getId() { return id; }
-    public String getName() { return name; }
-    public String getEmail() { return email; }
-}
-
-// Core principle: Specific exceptions
-public class UserNotFoundException extends Exception {
-    public UserNotFoundException(String message) {
-        super(message);
-    }
-}
-```
-
-## Essential Object-Oriented Patterns
-- **Single Responsibility**: Each class should have one reason to change
-- **Dependency Injection**: Use constructor injection for required dependencies
-- **Interface Segregation**: Keep interfaces focused and minimal
-- **Composition over Inheritance**: Favor composition for flexibility
-
-## Error Handling Essentials
-- **Checked vs Unchecked**: Use checked exceptions for recoverable conditions
-- **Exception Hierarchy**: Create meaningful exception hierarchies
-- **Resource Management**: Use try-with-resources for automatic resource cleanup
-- **Logging**: Log exceptions appropriately with context
-
-```java
-// Core principle: Resource management and exception handling
-public class UserService {
-    private final UserRepository userRepository;
-    
-    public UserService(UserRepository userRepository) {
-        this.userRepository = Objects.requireNonNull(userRepository);
-    }
-    
-    public User findUser(String id) throws UserNotFoundException {
-        try {
-            Optional<User> user = userRepository.findById(id);
-            return user.orElseThrow(() -> 
-                new UserNotFoundException("User not found with id: " + id));
-        } catch (DataAccessException e) {
-            throw new UserNotFoundException("Error retrieving user: " + e.getMessage(), e);
-        }
-    }
-}
-```
-
-## Modern Java Features
-- **Optional**: Use Optional to handle null values safely
-- **Streams**: Use streams for data processing and filtering
-- **Lambda Expressions**: Use lambdas for functional programming patterns
-- **Records**: Use records for simple data carriers (Java 14+)
-
-## Testing Essentials
-- **Unit Tests**: Use JUnit 5 for unit testing
-- **Test Organization**: Follow Given-When-Then or Arrange-Act-Assert patterns
-- **Mocking**: Use Mockito for mocking dependencies
-- **Integration Tests**: Test component interactions properly
-
-## Performance Guidelines
-- **String Handling**: Use StringBuilder for string concatenation in loops
-- **Collection Choice**: Choose appropriate collection types for use cases
-- **Memory Management**: Understand garbage collection behavior
-- **Profiling**: Use profiling tools to identify performance bottlenecks
-
-## Concurrency Guidelines
-- **Thread Safety**: Design for thread safety when needed
-- **Concurrent Collections**: Use concurrent collections appropriately
-- **ExecutorService**: Use thread pools instead of creating threads manually
-- **Synchronization**: Use proper synchronization mechanisms
-
-## Code Quality Essentials
-- **Code Formatting**: Use consistent code formatting and style
-- **Static Analysis**: Use tools like SpotBugs, PMD, and Checkstyle
-- **Documentation**: Write clear Javadoc for public APIs
-- **Clean Code**: Follow clean code principles and naming conventions
-
-Apply these core Java principles to write robust, maintainable, and efficient Java applications following language best practices and modern Java idioms.

package/.claude/workflows/cli-templates/tech-stacks/javascript-dev.md

@@ -1,58 +0,0 @@
----
-name: javascript-dev
-description: JavaScript and Node.js core development principles and essential practices
----
-
-# JavaScript Development Guidelines
-
-You are now operating under JavaScript/Node.js core development principles. Focus on essential practices without dictating project structure.
-
-## Core Language Principles
-
-### Naming Conventions
-- **Variables/Functions**: camelCase (`getUserData`, `isValid`)
-- **Constants**: SCREAMING_SNAKE_CASE (`API_ENDPOINT`, `MAX_RETRIES`)
-- **Classes**: PascalCase (`UserService`, `ApiClient`)
-
-### Essential Function Guidelines
-- **Pure Functions**: Prefer functions that don't mutate inputs
-- **Async/Await**: Use instead of Promises for better readability
-- **Error Handling**: Always handle errors explicitly, never silently fail
-
-```javascript
-// Core principle: Clear error handling
-async function fetchData(id) {
-  try {
-    const response = await api.get(`/data/${id}`);
-    return response.data;
-  } catch (error) {
-    throw new DataFetchError(`Failed to fetch data for ${id}: ${error.message}`);
-  }
-}
-```
-
-## Essential Testing Practices
-- **Test Names**: Describe behavior clearly (`should return user when ID exists`)
-- **Arrange-Act-Assert**: Structure tests consistently
-- **Mock External Dependencies**: Isolate units under test
-- **Test Edge Cases**: Include error conditions and boundary values
-
-## Code Quality Essentials
-- **Consistent Formatting**: Use automated formatting (Prettier)
-- **Linting**: Catch common errors early (ESLint)
-- **Type Safety**: Consider TypeScript for larger projects
-- **Input Validation**: Validate all external inputs
-
-## Security Core Principles
-- **Input Sanitization**: Never trust user input
-- **Environment Variables**: Keep secrets out of code
-- **Dependency Management**: Regularly audit and update packages
-- **Error Messages**: Don't expose internal details to users
-
-## Performance Guidelines
-- **Avoid Premature Optimization**: Write clear code first
-- **Use Modern Array Methods**: `map`, `filter`, `reduce` over manual loops
-- **Template Literals**: For string formatting over concatenation
-- **Object Destructuring**: For cleaner variable extraction
-
-Apply these core JavaScript principles to ensure clean, maintainable, and secure code without imposing specific project structures or tool choices.

package/.claude/workflows/cli-templates/tech-stacks/python-dev.md

@@ -1,79 +0,0 @@
----
-name: python-dev
-description: Python core development principles following PEP 8 and essential practices
----
-
-# Python Development Guidelines
-
-You are now operating under Python core development principles. Focus on essential PEP 8 practices without dictating project structure.
-
-## Core Language Principles
-
-### Naming Conventions (PEP 8)
-- **Variables/Functions**: snake_case (`get_user_data`, `is_valid`)
-- **Constants**: SCREAMING_SNAKE_CASE (`API_ENDPOINT`, `MAX_RETRIES`)
-- **Classes**: PascalCase (`UserService`, `ApiClient`)
-- **Private**: Single underscore prefix (`_private_method`)
-
-### Essential Function Guidelines
-- **Type Hints**: Use for parameters and return values when helpful
-- **Single Responsibility**: Each function should do one thing well
-- **Explicit Error Handling**: Create specific exception classes
-- **Context Managers**: Use `with` statements for resource management
-
-```python
-from typing import List, Optional
-
-def calculate_total(items: List[dict]) -> float:
-    """Calculate total price of items."""
-    if not items:
-        raise ValueError("Items list cannot be empty")
-    return sum(item.get('price', 0) for item in items)
-
-# Core principle: Specific exceptions
-class UserNotFoundError(Exception):
-    """Raised when user cannot be found."""
-    pass
-```
-
-## Essential Testing Practices
-- **Test Structure**: Given-When-Then pattern
-- **Descriptive Names**: Test names should describe behavior
-- **Mock External Dependencies**: Isolate units under test
-- **Edge Cases**: Test error conditions and boundary values
-
-## Code Quality Essentials
-- **PEP 8 Compliance**: Follow standard Python style guide
-- **Type Checking**: Use mypy or similar for type safety
-- **Automated Formatting**: Use Black or similar formatter
-- **Import Organization**: Keep imports organized and minimal
-
-## Security Core Principles
-- **Input Validation**: Validate all external inputs
-- **Parameterized Queries**: Never use string interpolation for SQL
-- **Environment Variables**: Keep secrets out of code
-- **Dependency Management**: Regularly audit packages for vulnerabilities
-
-```python
-# Core principle: Safe database queries
-from sqlalchemy import text
-
-def get_user_by_email(email: str) -> Optional[User]:
-    query = text("SELECT * FROM users WHERE email = :email")
-    result = db.execute(query, {"email": email})
-    return result.fetchone()
-```
-
-## Modern Python Features
-- **F-strings**: Use for string formatting (`f"Hello {name}"`)
-- **Pathlib**: Use `pathlib.Path` instead of `os.path` 
-- **Dataclasses**: Use for simple data containers
-- **List/Dict Comprehensions**: Use appropriately for clarity
-
-## Performance Guidelines
-- **Avoid Premature Optimization**: Write clear code first
-- **Use Built-in Functions**: Leverage Python's built-in efficiency
-- **Generator Expressions**: For memory efficiency with large datasets
-- **Context Managers**: Ensure proper resource cleanup
-
-Apply these core Python principles to ensure clean, maintainable, and Pythonic code without imposing specific frameworks or project structures.

package/.claude/workflows/cli-templates/tech-stacks/react-dev.md

@@ -1,103 +0,0 @@
----
-name: react-dev
-description: React core development principles with hooks and modern patterns
----
-
-# React Development Guidelines
-
-You are now operating under React core development principles. Focus on essential React patterns without dictating project structure.
-
-## Core React Principles
-
-### Component Guidelines
-- **Functional Components**: Use functional components with hooks over class components
-- **Component Naming**: PascalCase for components (`UserProfile`, `NavigationBar`)
-- **Single Responsibility**: Each component should have one clear purpose
-- **Props Interface**: Define clear prop types (TypeScript when possible)
-
-### Essential Hook Patterns
-- **useState**: For component-level state management
-- **useEffect**: Handle side effects with proper cleanup
-- **useCallback**: Memoize functions to prevent unnecessary re-renders
-- **useMemo**: Memoize expensive calculations
-- **Custom Hooks**: Extract reusable stateful logic
-
-```jsx
-// Core principle: Custom hooks for reusable logic
-function useUser(userId) {
-  const [user, setUser] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-
-  useEffect(() => {
-    if (!userId) return;
-    
-    const fetchUser = async () => {
-      try {
-        setLoading(true);
-        const userData = await api.getUser(userId);
-        setUser(userData);
-      } catch (err) {
-        setError(err);
-      } finally {
-        setLoading(false);
-      }
-    };
-
-    fetchUser();
-  }, [userId]);
-
-  return { user, loading, error };
-}
-```
-
-## Essential Testing Practices
-- **Test Behavior**: Test what users see and interact with, not implementation
-- **React Testing Library**: Preferred over enzyme for component testing
-- **Mock External Dependencies**: Keep tests isolated and fast
-- **Accessibility Testing**: Include accessibility assertions in tests
-
-## Performance Core Principles
-- **Avoid Premature Optimization**: Write clear code first
-- **React.memo**: Only when profiling shows unnecessary re-renders
-- **useCallback/useMemo**: Use judiciously based on actual performance needs
-- **Key Props**: Always provide stable, unique keys for list items
-
-## State Management Guidelines
-- **Local State First**: Use useState for component-specific state
-- **Lift State Up**: When multiple components need the same data
-- **Context Sparingly**: Only for truly global state (theme, auth, etc.)
-- **External Libraries**: Consider Redux Toolkit, Zustand for complex global state
-
-```jsx
-// Core principle: Context with proper error boundaries
-const UserContext = createContext();
-
-export const useUser = () => {
-  const context = useContext(UserContext);
-  if (!context) {
-    throw new Error('useUser must be used within UserProvider');
-  }
-  return context;
-};
-```
-
-## Error Handling Essentials
-- **Error Boundaries**: Implement to catch React component errors
-- **Async Error Handling**: Use try-catch in useEffect and event handlers
-- **User-Friendly Messages**: Show helpful error states to users
-- **Error Recovery**: Provide ways for users to recover from errors
-
-## Accessibility Core Principles
-- **Semantic HTML**: Use appropriate HTML elements first
-- **ARIA Labels**: Add when semantic HTML isn't sufficient
-- **Keyboard Navigation**: Ensure all interactive elements are keyboard accessible
-- **Focus Management**: Handle focus properly for dynamic content
-
-## Code Quality Essentials
-- **ESLint React Rules**: Use React-specific linting rules
-- **TypeScript**: Use for prop types and state management
-- **Consistent Formatting**: Use Prettier or similar
-- **Component Composition**: Favor composition over complex inheritance
-
-Apply these core React principles to ensure maintainable, performant, and accessible components without imposing specific architectural decisions.

package/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md

@@ -1,83 +0,0 @@
----
-name: typescript-dev
-description: TypeScript core principles for type safety and maintainable code
----
-
-# TypeScript Development Guidelines
-
-You are now operating under TypeScript core principles. Focus on essential type safety practices without dictating project structure.
-
-## Core TypeScript Principles
-
-### Essential Type Guidelines
-- **Strict Configuration**: Enable strict TypeScript settings for maximum type safety
-- **Explicit Typing**: Type function parameters and return values explicitly
-- **Interface vs Type**: Use interfaces for objects, types for unions and computations
-- **Generic Constraints**: Use generics for reusable, type-safe components
-
-```typescript
-// Core principle: Clear type definitions
-interface User {
-  id: string;
-  name: string;
-  email: string;
-  createdAt: Date;
-}
-
-// Core principle: Generic constraints
-function findById<T extends { id: string }>(items: T[], id: string): T | undefined {
-  return items.find(item => item.id === id);
-}
-
-// Core principle: Union types for controlled values
-type Status = 'pending' | 'approved' | 'rejected';
-```
-
-## Type Safety Essentials
-- **No Any**: Avoid `any` type, use `unknown` when type is truly unknown
-- **Null Safety**: Handle null/undefined explicitly with strict null checks
-- **Type Guards**: Use type predicates and guards for runtime type checking
-- **Assertion Functions**: Create functions that narrow types safely
-
-```typescript
-// Core principle: Type guards for runtime safety
-function isUser(value: unknown): value is User {
-  return typeof value === 'object' && 
-         value !== null && 
-         typeof (value as User).id === 'string';
-}
-
-// Core principle: Never use any, use unknown
-function processApiResponse(response: unknown): User | null {
-  if (isUser(response)) {
-    return response;
-  }
-  return null;
-}
-```
-
-## Essential Error Handling
-- **Typed Errors**: Create specific error types for different failure modes
-- **Result Types**: Consider Result/Either patterns for error handling
-- **Promise Typing**: Properly type async functions and error states
-- **Error Boundaries**: Type error boundary props and state properly
-
-## Performance Guidelines
-- **Avoid Excessive Generics**: Don't over-engineer type parameters
-- **Compile-Time Checks**: Leverage TypeScript for compile-time validation
-- **Type Inference**: Let TypeScript infer types when obvious
-- **Utility Types**: Use built-in utility types (Partial, Pick, Omit, etc.)
-
-## Testing with Types
-- **Test Type Assertions**: Ensure tests validate both runtime and compile-time behavior
-- **Mock Typing**: Properly type test mocks and fixtures
-- **Type-Only Tests**: Use TypeScript compiler API for pure type testing
-- **Coverage**: Include type coverage in your quality metrics
-
-## Configuration Essentials
-- **Strict Mode**: Always enable strict mode in tsconfig.json
-- **Path Mapping**: Use path mapping for cleaner imports
-- **Incremental Compilation**: Enable for faster builds
-- **Source Maps**: Generate source maps for debugging
-
-Apply these core TypeScript principles to ensure type-safe, maintainable code without imposing specific architectural patterns or tooling choices.

package/.claude/workflows/cli-templates/ui-design/systems/animation-tokens.json

@@ -1,247 +0,0 @@
-{
-  "$schema": "https://tr.designtokens.org/format/",
-
-  "duration": {
-    "$type": "duration",
-    "instant": { "$value": "0ms" },
-    "fast": { "$value": "150ms" },
-    "normal": { "$value": "300ms" },
-    "slow": { "$value": "500ms" },
-    "slower": { "$value": "1000ms" }
-  },
-
-  "easing": {
-    "$type": "cubicBezier",
-    "linear": { "$value": "linear" },
-    "ease-in": { "$value": "cubic-bezier(0.4, 0, 1, 1)" },
-    "ease-out": { "$value": "cubic-bezier(0, 0, 0.2, 1)" },
-    "ease-in-out": { "$value": "cubic-bezier(0.4, 0, 0.2, 1)" },
-    "spring": { "$value": "cubic-bezier(0.68, -0.55, 0.265, 1.55)" },
-    "bounce": { "$value": "cubic-bezier(0.68, -0.6, 0.32, 1.6)" }
-  },
-
-  "keyframes": {
-    "_comment_pattern": "Define pairs (in/out, open/close, enter/exit)",
-    "_comment_required": "Required keyframes for components",
-
-    "fade-in": {
-      "0%": { "opacity": "0" },
-      "100%": { "opacity": "1" }
-    },
-    "fade-out": {
-      "_comment": "reverse of fade-in",
-      "0%": { "opacity": "1" },
-      "100%": { "opacity": "0" }
-    },
-
-    "slide-up": {
-      "0%": { "transform": "translateY(10px)", "opacity": "0" },
-      "100%": { "transform": "translateY(0)", "opacity": "1" }
-    },
-    "slide-down": {
-      "_comment": "reverse direction",
-      "0%": { "transform": "translateY(0)", "opacity": "1" },
-      "100%": { "transform": "translateY(10px)", "opacity": "0" }
-    },
-
-    "scale-in": {
-      "0%": { "transform": "scale(0.95)", "opacity": "0" },
-      "100%": { "transform": "scale(1)", "opacity": "1" }
-    },
-    "scale-out": {
-      "_comment": "reverse of scale-in",
-      "0%": { "transform": "scale(1)", "opacity": "1" },
-      "100%": { "transform": "scale(0.95)", "opacity": "0" }
-    },
-
-    "accordion-down": {
-      "0%": { "height": "0", "opacity": "0" },
-      "100%": { "height": "var(--radix-accordion-content-height)", "opacity": "1" }
-    },
-    "accordion-up": {
-      "_comment": "reverse",
-      "0%": { "height": "var(--radix-accordion-content-height)", "opacity": "1" },
-      "100%": { "height": "0", "opacity": "0" }
-    },
-
-    "dialog-open": {
-      "0%": { "transform": "translate(-50%, -48%) scale(0.96)", "opacity": "0" },
-      "100%": { "transform": "translate(-50%, -50%) scale(1)", "opacity": "1" }
-    },
-    "dialog-close": {
-      "_comment": "reverse",
-      "0%": { "transform": "translate(-50%, -50%) scale(1)", "opacity": "1" },
-      "100%": { "transform": "translate(-50%, -48%) scale(0.96)", "opacity": "0" }
-    },
-
-    "dropdown-open": {
-      "0%": { "transform": "scale(0.95) translateY(-4px)", "opacity": "0" },
-      "100%": { "transform": "scale(1) translateY(0)", "opacity": "1" }
-    },
-    "dropdown-close": {
-      "_comment": "reverse",
-      "0%": { "transform": "scale(1) translateY(0)", "opacity": "1" },
-      "100%": { "transform": "scale(0.95) translateY(-4px)", "opacity": "0" }
-    },
-
-    "toast-enter": {
-      "0%": { "transform": "translateX(100%)", "opacity": "0" },
-      "100%": { "transform": "translateX(0)", "opacity": "1" }
-    },
-    "toast-exit": {
-      "_comment": "reverse",
-      "0%": { "transform": "translateX(0)", "opacity": "1" },
-      "100%": { "transform": "translateX(100%)", "opacity": "0" }
-    },
-
-    "spin": {
-      "0%": { "transform": "rotate(0deg)" },
-      "100%": { "transform": "rotate(360deg)" }
-    },
-    "pulse": {
-      "0%, 100%": { "opacity": "1" },
-      "50%": { "opacity": "0.5" }
-    }
-  },
-
-  "interactions": {
-    "_comment_pattern": "Define for each interactive component state",
-    "_structure": {
-      "property": "string - CSS properties (comma-separated)",
-      "duration": "{duration.*}",
-      "easing": "{easing.*}"
-    },
-
-    "button-hover": {
-      "property": "background-color, transform",
-      "duration": "{duration.fast}",
-      "easing": "{easing.ease-out}"
-    },
-    "button-active": {
-      "property": "transform",
-      "duration": "{duration.instant}",
-      "easing": "{easing.ease-in}"
-    },
-    "card-hover": {
-      "property": "box-shadow, transform",
-      "duration": "{duration.normal}",
-      "easing": "{easing.ease-in-out}"
-    },
-    "input-focus": {
-      "property": "border-color, box-shadow",
-      "duration": "{duration.fast}",
-      "easing": "{easing.ease-out}"
-    },
-    "dropdown-toggle": {
-      "property": "opacity, transform",
-      "duration": "{duration.fast}",
-      "easing": "{easing.ease-out}"
-    },
-    "accordion-toggle": {
-      "property": "height, opacity",
-      "duration": "{duration.normal}",
-      "easing": "{easing.ease-in-out}"
-    },
-    "dialog-toggle": {
-      "property": "opacity, transform",
-      "duration": "{duration.normal}",
-      "easing": "{easing.spring}"
-    },
-    "tabs-switch": {
-      "property": "color, border-color",
-      "duration": "{duration.fast}",
-      "easing": "{easing.ease-in-out}"
-    }
-  },
-
-  "transitions": {
-    "default": { "$value": "all {duration.normal} {easing.ease-in-out}" },
-    "colors": { "$value": "color {duration.fast} {easing.linear}, background-color {duration.fast} {easing.linear}" },
-    "transform": { "$value": "transform {duration.normal} {easing.spring}" },
-    "opacity": { "$value": "opacity {duration.fast} {easing.linear}" },
-    "all-smooth": { "$value": "all {duration.slow} {easing.ease-in-out}" }
-  },
-
-  "component_animations": {
-    "_comment_pattern": "Map each component to its animations - MUST match design-tokens.json component list",
-    "_structure": {
-      "stateOrInteraction": {
-        "animation": "keyframe-name {duration.*} {easing.*} OR none",
-        "transition": "{interactions.*} OR none"
-      }
-    },
-
-    "button": {
-      "hover": { "animation": "none", "transition": "{interactions.button-hover}" },
-      "active": { "animation": "none", "transition": "{interactions.button-active}" }
-    },
-    "card": {
-      "hover": { "animation": "none", "transition": "{interactions.card-hover}" }
-    },
-    "input": {
-      "focus": { "animation": "none", "transition": "{interactions.input-focus}" }
-    },
-    "dialog": {
-      "open": { "animation": "dialog-open {duration.normal} {easing.spring}" },
-      "close": { "animation": "dialog-close {duration.normal} {easing.ease-in}" }
-    },
-    "dropdown": {
-      "open": { "animation": "dropdown-open {duration.fast} {easing.ease-out}" },
-      "close": { "animation": "dropdown-close {duration.fast} {easing.ease-in}" }
-    },
-    "toast": {
-      "enter": { "animation": "toast-enter {duration.normal} {easing.ease-out}" },
-      "exit": { "animation": "toast-exit {duration.normal} {easing.ease-in}" }
-    },
-    "accordion": {
-      "open": { "animation": "accordion-down {duration.normal} {easing.ease-out}" },
-      "close": { "animation": "accordion-up {duration.normal} {easing.ease-in}" }
-    },
-    "_comment_missing": "Add mappings for: tabs, switch, checkbox, badge, alert"
-  },
-
-  "accessibility": {
-    "prefers_reduced_motion": {
-      "duration": "0ms",
-      "keyframes": {},
-      "note": "Disable animations when user prefers reduced motion",
-      "css_rule": "@media (prefers-reduced-motion: reduce) { *, *::before, *::after { animation-duration: 0.01ms !important; animation-iteration-count: 1 !important; transition-duration: 0.01ms !important; } }"
-    }
-  },
-
-  "_metadata": {
-    "version": "string",
-    "created": "ISO timestamp",
-    "source": "code-import|explore|text",
-    "code_snippets": [
-      {
-        "animation_name": "string - keyframe/transition name",
-        "source_file": "string - absolute path",
-        "line_start": "number",
-        "line_end": "number",
-        "snippet": "string - complete @keyframes or transition code",
-        "context_type": "css-keyframes|css-transition|js-animation|scss-animation|etc"
-      }
-    ]
-  },
-
-  "_field_rules": {
-    "schema": "$schema MUST reference W3C Design Tokens format specification",
-    "duration_wrapper": "All duration values MUST use $value wrapper with ms units",
-    "easing_wrapper": "All easing values MUST use $value wrapper with standard CSS easing or cubic-bezier()",
-    "keyframes": "keyframes MUST define complete component state animations (open/close, enter/exit)",
-    "interactions_refs": "interactions MUST reference duration and easing using {token.path} syntax",
-    "component_mapping": "component_animations MUST map component states to specific keyframes and transitions",
-    "component_coverage": "component_animations MUST be defined for all interactive and stateful components",
-    "transitions_wrapper": "transitions MUST use $value wrapper for complete transition definitions",
-    "accessibility": "accessibility.prefers_reduced_motion MUST be included with CSS media query rule",
-    "code_snippets": "_metadata.code_snippets ONLY present in Code Import mode"
-  },
-
-  "_animation_component_integration": {
-    "requirement": "Each component in design-tokens.json component section MUST have corresponding entry in component_animations",
-    "state_based": "State-based animations (dialog.open, accordion.close) MUST use keyframe animations",
-    "interaction": "Interaction animations (button.hover, input.focus) MUST use transitions",
-    "consistency": "All animation references use {token.path} syntax for consistency"
-  }
-}