moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-java/SKILL.md

@@ -1,22 +1,25 @@
 ---
-name: moai-lang-java
-description: Java 21 LTS development specialist covering Spring Boot 3.3, virtual threads, pattern matching, and enterprise patterns. Use when building enterprise applications, microservices, or Spring projects.
-version: 1.0.0
-category: language
-tags: [java, spring-boot, jpa, hibernate, virtual-threads, enterprise]
-context7-libraries: [/spring-projects/spring-boot, /spring-projects/spring-framework, /spring-projects/spring-security]
-related-skills: [moai-lang-kotlin, moai-domain-backend]
-updated: 2025-12-07
-status: active
+name: "moai-lang-java"
+description: "Java 21 LTS development specialist covering Spring Boot 3.3, virtual threads, pattern matching, and enterprise patterns. Use when building enterprise applications, microservices, or Spring projects."
+version: 1.1.0
+category: "language"
+modularized: false
+user-invocable: false
+tags: ['java', 'spring-boot', 'jpa', 'hibernate', 'virtual-threads', 'enterprise']
+context7-libraries: ['/spring-projects/spring-boot', '/spring-projects/spring-framework', '/spring-projects/spring-security']
+related-skills: ['moai-lang-kotlin', 'moai-domain-backend']
+updated: 2026-01-11
+status: "active"
 ---
 
 ## Quick Reference (30 seconds)
 
 Java 21 LTS Expert - Enterprise development with Spring Boot 3.3, Virtual Threads, and modern Java features.
 
-Auto-Triggers: Java files (`.java`), build files (`pom.xml`, `build.gradle`, `build.gradle.kts`)
+Auto-Triggers: Java files with .java extension, build files including pom.xml, build.gradle, or build.gradle.kts
 
 Core Capabilities:
+
 - Java 21 LTS: Virtual threads, pattern matching, record patterns, sealed classes
 - Spring Boot 3.3: REST controllers, services, repositories, WebFlux reactive
 - Spring Security 6: JWT authentication, OAuth2, role-based access control
@@ -30,206 +33,51 @@ Core Capabilities:
 
 ### Java 21 LTS Features
 
-Virtual Threads (Project Loom):
-```java
-// Lightweight concurrent programming
-try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
-    IntStream.range(0, 10_000).forEach(i ->
-        executor.submit(() -> {
-            Thread.sleep(Duration.ofSeconds(1));
-            return i;
-        })
-    );
-}
-
-// Structured concurrency (preview)
-try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
-    Supplier<User> user = scope.fork(() -> fetchUser(userId));
-    Supplier<List<Order>> orders = scope.fork(() -> fetchOrders(userId));
-    scope.join().throwIfFailed();
-    return new UserWithOrders(user.get(), orders.get());
-}
-```
+Virtual Threads with Project Loom:
+
+Use try-with-resources on Executors.newVirtualThreadPerTaskExecutor. Call IntStream.range from 0 to 10000 and forEach to submit tasks that sleep for one second and return the iteration value.
+
+Structured Concurrency Preview Pattern:
+
+Use try-with-resources on new StructuredTaskScope.ShutdownOnFailure. Fork tasks for fetching user and orders by calling scope.fork with lambda expressions. Call scope.join then throwIfFailed. Return new composite object with results from both task suppliers.
 
 Pattern Matching for Switch:
-```java
-String describe(Object obj) {
-    return switch (obj) {
-        case Integer i when i > 0 -> "positive integer: " + i;
-        case Integer i -> "non-positive integer: " + i;
-        case String s -> "string of length " + s.length();
-        case List<?> list -> "list with " + list.size() + " elements";
-        case null -> "null value";
-        default -> "unknown type";
-    };
-}
-```
+
+Create describe method taking Object parameter. Use switch expression with cases for Integer i with guard condition i greater than 0 returning positive integer message, Integer i returning non-positive message, String s returning length message, List with wildcard returning size message, null returning null value, and default returning unknown type.
 
 Record Patterns and Sealed Classes:
-```java
-record Point(int x, int y) {}
-record Rectangle(Point topLeft, Point bottomRight) {}
-
-int area(Rectangle rect) {
-    return switch (rect) {
-        case Rectangle(Point(var x1, var y1), Point(var x2, var y2)) ->
-            Math.abs((x2 - x1) * (y2 - y1));
-    };
-}
-
-public sealed interface Shape permits Circle, Rectangle {
-    double area();
-}
-public record Circle(double radius) implements Shape {
-    public double area() { return Math.PI * radius * radius; }
-}
-```
+
+Define Point record with int x and int y. Define Rectangle record with Point topLeft and Point bottomRight. Create area method that uses switch with Rectangle pattern destructuring both Point components into variables, returning absolute value of width times height. Define sealed Shape interface permitting Circle and Rectangle. Implement Circle record with area method using PI times radius squared.
 
 ### Spring Boot 3.3
 
-REST Controller:
-```java
-@RestController
-@RequestMapping("/api/users")
-@RequiredArgsConstructor
-public class UserController {
-    private final UserService userService;
-
-    @GetMapping("/{id}")
-    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
-        return userService.findById(id)
-            .map(ResponseEntity::ok)
-            .orElse(ResponseEntity.notFound().build());
-    }
-
-    @PostMapping
-    public ResponseEntity<UserDto> createUser(@Valid @RequestBody CreateUserRequest request) {
-        UserDto user = userService.create(request);
-        URI location = URI.create("/api/users/" + user.id());
-        return ResponseEntity.created(location).body(user);
-    }
-
-    @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
-        return userService.delete(id)
-            ? ResponseEntity.noContent().build()
-            : ResponseEntity.notFound().build();
-    }
-}
-```
-
-Service Layer:
-```java
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class UserService {
-    private final UserRepository userRepository;
-    private final PasswordEncoder passwordEncoder;
-
-    public Optional<User> findById(Long id) {
-        return userRepository.findById(id);
-    }
-
-    @Transactional
-    public User create(CreateUserRequest request) {
-        if (userRepository.existsByEmail(request.email())) {
-            throw new DuplicateEmailException(request.email());
-        }
-        var user = User.builder()
-            .name(request.name())
-            .email(request.email())
-            .passwordHash(passwordEncoder.encode(request.password()))
-            .status(UserStatus.PENDING)
-            .build();
-        return userRepository.save(user);
-    }
-}
-```
+REST Controller Pattern:
+
+Create UserController with RestController annotation, RequestMapping for api/users, and RequiredArgsConstructor. Inject UserService. Create getUser method with GetMapping and PathVariable for id, returning ResponseEntity that maps findById result to ok or returns notFound. Create createUser method with PostMapping, Valid annotation, and RequestBody for CreateUserRequest. Create user, build URI location, return created response with body. Create deleteUser method with DeleteMapping that returns noContent or notFound based on service result.
+
+Service Layer Pattern:
+
+Create UserService with Service, RequiredArgsConstructor, and Transactional readOnly true annotations. Inject UserRepository and PasswordEncoder. Create findById method returning Optional. Create transactional create method that checks for duplicate email throwing DuplicateEmailException, builds User with builder pattern encoding password, and saves to repository.
 
 ### Spring Security 6
 
-Security Configuration:
-```java
-@Configuration
-@EnableWebSecurity
-public class SecurityConfig {
-    @Bean
-    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
-        return http
-            .authorizeHttpRequests(auth -> auth
-                .requestMatchers("/api/public/**").permitAll()
-                .requestMatchers("/api/admin/**").hasRole("ADMIN")
-                .anyRequest().authenticated()
-            )
-            .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
-            .sessionManagement(session ->
-                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
-            .csrf(csrf -> csrf.disable())
-            .build();
-    }
-
-    @Bean
-    public PasswordEncoder passwordEncoder() {
-        return new BCryptPasswordEncoder();
-    }
-}
-```
+Security Configuration Pattern:
+
+Create SecurityConfig with Configuration and EnableWebSecurity annotations. Define filterChain Bean taking HttpSecurity. Configure authorizeHttpRequests with permitAll for public API paths, hasRole ADMIN for admin paths, and authenticated for all other requests. Configure oauth2ResourceServer with jwt default. Set sessionManagement to STATELESS and disable csrf. Define passwordEncoder Bean returning BCryptPasswordEncoder.
 
 ### JPA/Hibernate Patterns
 
-Entity Definition:
-```java
-@Entity
-@Table(name = "users")
-@Getter @Setter
-@NoArgsConstructor @Builder
-public class User {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @Column(nullable = false)
-    private String name;
-
-    @Column(nullable = false, unique = true)
-    private String email;
-
-    @Enumerated(EnumType.STRING)
-    private UserStatus status;
-
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
-    private List<Order> orders = new ArrayList<>();
-}
-```
-
-Repository with Custom Queries:
-```java
-public interface UserRepository extends JpaRepository<User, Long> {
-    Optional<User> findByEmail(String email);
-    boolean existsByEmail(String email);
-
-    @Query("SELECT u FROM User u LEFT JOIN FETCH u.orders WHERE u.id = :id")
-    Optional<User> findByIdWithOrders(@Param("id") Long id);
-
-    Page<User> findByNameContainingIgnoreCase(String name, Pageable pageable);
-}
-```
-
-DTOs as Records:
-```java
-public record UserDto(Long id, String name, String email, UserStatus status) {
-    public static UserDto from(User user) {
-        return new UserDto(user.getId(), user.getName(), user.getEmail(), user.getStatus());
-    }
-}
-
-public record CreateUserRequest(
-    @NotBlank @Size(min = 2, max = 100) String name,
-    @NotBlank @Email String email,
-    @NotBlank @Size(min = 8) String password
-) {}
-```
+Entity Definition Pattern:
+
+Create User entity with Entity and Table annotations. Add Lombok Getter, Setter, NoArgsConstructor, and Builder annotations. Define id with Id and GeneratedValue IDENTITY. Define name and email with Column nullable false, email also unique. Define status with Enumerated STRING. Define orders with OneToMany mappedBy user, cascade ALL, and orphanRemoval true.
+
+Repository with Custom Queries Pattern:
+
+Create UserRepository extending JpaRepository. Add findByEmail returning Optional. Add existsByEmail returning boolean. Add Query annotation for JPQL with LEFT JOIN FETCH for findByIdWithOrders using Param annotation. Add findByNameContainingIgnoreCase with Pageable for pagination.
+
+DTOs as Records Pattern:
+
+Create UserDto record with id, name, email, and status. Add static from factory method that constructs record from User entity. Create CreateUserRequest record with NotBlank and Size annotations for name, NotBlank and Email for email, NotBlank and Size min 8 for password.
 
 ---
 
@@ -237,137 +85,64 @@ public record CreateUserRequest(
 
 ### Virtual Threads Integration
 
-```java
-@Service
-@RequiredArgsConstructor
-public class AsyncUserService {
-    public UserWithDetails fetchUserDetails(Long userId) throws Exception {
-        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
-            Supplier<User> userTask = scope.fork(() -> userRepo.findById(userId).orElseThrow());
-            Supplier<List<Order>> ordersTask = scope.fork(() -> orderRepo.findByUserId(userId));
-            scope.join().throwIfFailed();
-            return new UserWithDetails(userTask.get(), ordersTask.get());
-        }
-    }
-
-    public void processUsersInParallel(List<Long> userIds) {
-        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
-            userIds.stream().map(id -> executor.submit(() -> processUser(id))).toList();
-        }
-    }
-}
-```
+Create AsyncUserService with Service and RequiredArgsConstructor annotations. Create fetchUserDetails method using StructuredTaskScope.ShutdownOnFailure in try-with-resources. Fork tasks for user and orders queries, join and throw if failed, return composite result. Create processUsersInParallel method using newVirtualThreadPerTaskExecutor and streaming user IDs to submit processing tasks.
 
 ### Build Configuration
 
-Maven 3.9:
-```xml
-<project>
-    <parent>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.3.0</version>
-    </parent>
-    <properties><java.version>21</java.version></properties>
-    <dependencies>
-        <dependency><groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId></dependency>
-        <dependency><groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-jpa</artifactId></dependency>
-    </dependencies>
-</project>
-```
-
-Gradle 8.5 (Kotlin DSL):
-```kotlin
-plugins {
-    id("org.springframework.boot") version "3.3.0"
-    id("io.spring.dependency-management") version "1.1.4"
-    java
-}
-java { toolchain { languageVersion = JavaLanguageVersion.of(21) } }
-dependencies {
-    implementation("org.springframework.boot:spring-boot-starter-web")
-    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
-    testImplementation("org.springframework.boot:spring-boot-starter-test")
-}
-```
+Maven 3.9 Pattern:
+
+Define project with parent for spring-boot-starter-parent version 3.3.0. Set java.version property to 21. Add dependencies for spring-boot-starter-web and spring-boot-starter-data-jpa.
+
+Gradle 8.5 Kotlin DSL Pattern:
+
+Apply plugins for org.springframework.boot, io.spring.dependency-management, and java. Set toolchain languageVersion to 21. Add implementation dependencies for web and data-jpa starters, testImplementation for test starter.
 
 ### Testing with JUnit 5
 
-Unit Testing:
-```java
-@ExtendWith(MockitoExtension.class)
-class UserServiceTest {
-    @Mock private UserRepository userRepository;
-    @InjectMocks private UserService userService;
-
-    @Test
-    void shouldCreateUser() {
-        when(userRepository.existsByEmail(anyString())).thenReturn(false);
-        when(userRepository.save(any())).thenReturn(User.builder().id(1L).build());
-        var result = userService.create(new CreateUserRequest("John", "john@test.com", "pass"));
-        assertThat(result.getId()).isEqualTo(1L);
-    }
-}
-```
-
-Integration Testing with TestContainers:
-```java
-@Testcontainers
-@SpringBootTest
-class UserRepositoryTest {
-    @Container
-    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine");
-
-    @DynamicPropertySource
-    static void props(DynamicPropertyRegistry registry) {
-        registry.add("spring.datasource.url", postgres::getJdbcUrl);
-    }
-
-    @Autowired UserRepository repo;
-
-    @Test
-    void shouldSaveUser() {
-        var user = repo.save(User.builder().name("John").email("john@test.com").build());
-        assertThat(user.getId()).isNotNull();
-    }
-}
-```
+Unit Testing Pattern:
+
+Create test class with ExtendWith MockitoExtension. Add Mock annotation for UserRepository. Add InjectMocks for UserService. Create shouldCreateUser test that stubs existsByEmail to return false and save to return user with id. Call service create and assertThat result id equals 1.
+
+Integration Testing with TestContainers Pattern:
+
+Create test class with Testcontainers and SpringBootTest annotations. Define static Container for PostgreSQL with postgres:16-alpine image. Add DynamicPropertySource to set datasource.url from container. Autowire repository. Create test that saves user and assertThat id isNotNull.
 
 ---
 
 ## Context7 Integration
 
 Library mappings for latest documentation:
-- `/spring-projects/spring-boot` - Spring Boot 3.3 documentation
-- `/spring-projects/spring-framework` - Spring Framework core
-- `/spring-projects/spring-security` - Spring Security 6
-- `/hibernate/hibernate-orm` - Hibernate 7 ORM patterns
-- `/junit-team/junit5` - JUnit 5 testing framework
+
+- spring-projects/spring-boot for Spring Boot 3.3 documentation
+- spring-projects/spring-framework for Spring Framework core
+- spring-projects/spring-security for Spring Security 6
+- hibernate/hibernate-orm for Hibernate 7 ORM patterns
+- junit-team/junit5 for JUnit 5 testing framework
 
 ---
 
 ## Works Well With
 
-- `moai-lang-kotlin` - Kotlin interoperability and Spring Kotlin extensions
-- `moai-domain-backend` - REST API, GraphQL, microservices architecture
-- `moai-domain-database` - JPA, Hibernate, R2DBC patterns
-- `moai-foundation-quality` - JUnit 5, Mockito, TestContainers integration
-- `moai-infra-docker` - JVM container optimization
+- moai-lang-kotlin for Kotlin interoperability and Spring Kotlin extensions
+- moai-domain-backend for REST API, GraphQL, and microservices architecture
+- moai-domain-database for JPA, Hibernate, and R2DBC patterns
+- moai-foundation-quality for JUnit 5, Mockito, and TestContainers integration
+- moai-infra-docker for JVM container optimization
 
 ---
 
 ## Troubleshooting
 
 Common Issues:
-- Version mismatch: `java -version`, check `JAVA_HOME` points to Java 21
-- Compilation errors: `mvn clean compile -X` or `gradle build --info`
-- Virtual thread issues: Ensure Java 21+ with `--enable-preview` if needed
-- JPA lazy loading: Use `@Transactional` or `JOIN FETCH` queries
+
+- Version mismatch: Run java -version and check JAVA_HOME points to Java 21
+- Compilation errors: Run mvn clean compile -X or gradle build --info
+- Virtual thread issues: Ensure Java 21+ with --enable-preview if needed
+- JPA lazy loading: Use Transactional annotation or JOIN FETCH queries
 
 Performance Tips:
-- Enable Virtual Threads: `spring.threads.virtual.enabled=true`
+
+- Enable Virtual Threads by setting spring.threads.virtual.enabled to true
 - Use GraalVM Native Image for faster startup
 - Configure connection pooling with HikariCP
 
@@ -376,10 +151,11 @@ Performance Tips:
 ## Advanced Documentation
 
 For comprehensive reference materials:
-- [reference.md](reference.md) - Java 21 features, Context7 mappings, performance
-- [examples.md](examples.md) - Production-ready Spring Boot examples
+
+- reference.md for Java 21 features, Context7 mappings, and performance
+- examples.md for production-ready Spring Boot examples
 
 ---
 
-Last Updated: 2025-12-07
-Status: Production Ready (v1.0.0)
+Last Updated: 2026-01-11
+Status: Production Ready (v1.1.0)

moai_adk/templates/.claude/skills/moai-lang-javascript/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: "moai-lang-javascript"
+description: "JavaScript ES2024+ development specialist covering Node.js 22 LTS, Bun 1.x (serve, SQLite, S3, shell, test), Deno 2.x, testing (Vitest, Jest), linting (ESLint 9, Biome), and backend frameworks (Express, Fastify, Hono). Use when developing JavaScript APIs, web applications, or Node.js projects."
+version: 1.2.0
+category: "language"
+modularized: false
+user-invocable: false
+tags:
+  [
+    "language",
+    "javascript",
+    "nodejs",
+    "bun",
+    "deno",
+    "vitest",
+    "eslint",
+    "express",
+  ]
+updated: 2026-01-11
+status: "active"
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+---
+
+## Quick Reference (30 seconds)
+
+JavaScript ES2024+ Development Specialist - Modern JavaScript with Node.js 22 LTS, multiple runtimes, and contemporary tooling.
+
+Auto-Triggers: Files with .js, .mjs, or .cjs extensions, package.json, Node.js projects, JavaScript discussions
+
+Core Stack:
+
+- ES2024+: Set methods, Promise.withResolvers, immutable arrays, import attributes
+- Node.js 22 LTS: Native TypeScript, built-in WebSocket, stable watch mode
+- Runtimes: Node.js 20 and 22 LTS, Deno 2.x, Bun 1.x
+- Testing: Vitest, Jest, Node.js test runner
+- Linting: ESLint 9 flat config, Biome
+- Bundlers: Vite, esbuild, Rollup
+- Frameworks: Express, Fastify, Hono, Koa
+
+Quick Commands:
+
+Create a Vite project using npm create vite with latest tag, project name, and vanilla template. Initialize with modern tooling using npm init and npm install with D flag for vitest, eslint, and eslint/js. Run with Node.js watch mode using node with watch flag. Run TypeScript directly in Node.js 22+ using node with experimental-strip-types flag.
+
+---
+
+## Implementation Guide (5 minutes)
+
+### ES2024 Key Features
+
+Set Operations:
+
+Create setA with values 1, 2, 3, 4 and setB with values 3, 4, 5, 6. Call setA.intersection with setB to get Set containing 3 and 4. Call setA.union with setB to get Set containing 1 through 6. Call setA.difference with setB to get Set containing 1 and 2. Call setA.symmetricDifference with setB to get Set containing 1, 2, 5, and 6. Call isSubsetOf, isSupersetOf, and isDisjointFrom methods for set comparisons.
+
+Promise.withResolvers:
+
+Create a createDeferred function that destructures promise, resolve, and reject from Promise.withResolvers call. Return an object with these three properties. Create a deferred instance, set a timeout to resolve with done after 1000 milliseconds, and await the promise for the result.
+
+Immutable Array Methods:
+
+Create original array with values 3, 1, 4, 1, 5. Call toSorted to get new sorted array without mutating original. Call toReversed to get new reversed array. Call toSpliced with index 1, delete count 2, and insert value 9. Call with method at index 2 with value 99 to get new array with replaced element. The original array remains unchanged.
+
+Object.groupBy and Map.groupBy:
+
+Create items array with objects containing type and name properties. Call Object.groupBy with items and a function that returns item.type to get an object with arrays grouped by type. Call Map.groupBy with the same arguments to get a Map with type keys and array values.
+
+### ES2025 Features
+
+Import Attributes for JSON Modules:
+
+Import config from config.json with type attribute set to json. Import styles from styles.css with type attribute set to css. Access config.apiUrl property.
+
+RegExp.escape:
+
+Create userInput string with special characters like parentheses. Call RegExp.escape with userInput to get escaped pattern string. Create new RegExp with the safe pattern.
+
+### Node.js 22 LTS Features
+
+Built-in WebSocket Client:
+
+Create new WebSocket with wss URL. Add event listener for open event that sends JSON stringified message. Add event listener for message event that parses event.data as JSON and logs the received data.
+
+Native TypeScript Support Experimental:
+
+Run .ts files directly in Node.js 22.6+ using node with experimental-strip-types flag. In Node.js 22.18+, type stripping is enabled by default so files can be run directly.
+
+Watch Mode Stable:
+
+Use node with watch flag for auto-restart on file changes. Use watch-path flag multiple times to watch specific directories like src and config.
+
+Permission Model:
+
+Use node with permission flag and allow-fs-read set to a specific path to restrict file system access. Use allow-net flag with domain name to restrict network access.
+
+### Backend Frameworks
+
+Express Traditional Pattern:
+
+Import express. Create app by calling express function. Use express.json middleware. Create a get endpoint at api/users that awaits database query and responds with json. Create a post endpoint that creates a user and responds with status 201 and json. Call listen on port 3000 with callback logging server running.
+
+Fastify High Performance Pattern:
+
+Import Fastify. Create fastify instance with logger set to true. Define userSchema with body containing type object, required array with name and email, and properties with validation constraints. Create a post endpoint with schema option and async handler that creates user and returns with code 201. Call listen with port 3000.
+
+Hono Edge-First Pattern:
+
+Import Hono and middleware functions. Create app instance. Use logger middleware for all routes. Use cors middleware for api routes. Create get endpoint at api/users that awaits database query and returns c.json. Create post endpoint with validator middleware that checks for required fields, then creates user and returns c.json with status 201. Export app as default.
+
+### Testing with Vitest
+
+Configuration:
+
+Create vitest.config.js with defineConfig. Set test object with globals true, environment node, and coverage with provider v8 and reporters for text, json, and html.
+
+Test Example:
+
+In test file, import describe, it, expect, vi, and beforeEach from vitest. Import functions to test. Create describe block for User Service. In beforeEach, call vi.clearAllMocks. Create it block for should create a user that awaits createUser and expects result to match object with name and email, and id to be defined. Create it block for should throw on invalid email that expects createUser to reject with Invalid email error.
+
+### ESLint 9 Flat Config
+
+Create eslint.config.js. Import js from eslint/js and globals. Export array with js.configs.recommended followed by object with languageOptions containing ecmaVersion 2025, sourceType module, and globals merged from globals.node and globals.es2025. Set rules for no-unused-vars with error and args ignore pattern, no-console with warn and allowed methods, prefer-const as error, and no-var as error.
+
+### Biome All-in-One
+
+Create biome.json with schema URL. Enable organizeImports. Set linter enabled with recommended rules. Set formatter enabled with indentStyle space and indentWidth 2. Under javascript.formatter, set quoteStyle to single and semicolons to always.
+
+---
+
+## Advanced Patterns
+
+For comprehensive documentation including advanced async patterns, module system details, performance optimization, and production deployment configurations, see:
+
+- reference.md for complete API reference, Context7 library mappings, and package manager comparison
+- examples.md for production-ready code examples, full-stack patterns, and testing templates
+
+### Context7 Integration
+
+For Node.js documentation, use context7 get library docs with nodejs/node and topics like esm modules async. For Express, use expressjs/express with middleware routing. For Fastify, use fastify/fastify with plugins hooks. For Hono, use honojs/hono with middleware validators. For Vitest, use vitest-dev/vitest with mocking coverage.
+
+---
+
+## Works Well With
+
+- moai-lang-typescript for TypeScript integration and type checking with JSDoc
+- moai-domain-backend for API design and microservices architecture
+- moai-domain-database for database integration and ORM patterns
+- moai-workflow-testing for TDD workflows and testing strategies
+- moai-foundation-quality for code quality standards
+- moai-essentials-debug for debugging JavaScript applications
+
+---
+
+## Quick Troubleshooting
+
+Module System Issues:
+
+Check package.json for type field. ESM uses type module with import and export. CommonJS uses type commonjs or omits the field and uses require and module.exports.
+
+Node.js Version Check:
+
+Run node with version flag for 20.x or 22.x LTS. Run npm with version flag for 10.x or later.
+
+Common Fixes:
+
+Clear npm cache with npm cache clean using force flag. Delete node_modules and package-lock.json then run npm install. Fix permission issues by setting npm config prefix to home directory npm-global folder.
+
+ESM and CommonJS Interop:
+
+To import CommonJS from ESM, import the default then destructure named exports from it. For dynamic import in CommonJS, use await import and destructure the default property.
+
+---
+
+Last Updated: 2026-01-11
+Status: Active (v1.2.0)