claudient 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudient",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The definitive Claude Code knowledge system — skills, agents, hooks, rules, and workflows.",
   "keywords": [
     "claude-code",
@@ -34,12 +34,14 @@
     "guides/",
     ".claude-plugin/",
     "CONTEXT.md",
-    "README.md"
+    "README.md",
+    "index.json"
   ],
   "engines": {
     "node": ">=18"
   },
   "scripts": {
-    "list": "node scripts/cli.js list"
+    "list": "node scripts/cli.js list",
+    "build-index": "node scripts/build-index.js"
   }
 }

package/scripts/build-index.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+// build-index.js — generates index.json, a machine-readable manifest of all content
+
+const fs = require('fs')
+const path = require('path')
+
+const ROOT = path.resolve(__dirname, '..')
+const LANGS = ['fr', 'de', 'nl', 'es']
+const SKILL_CATEGORIES = ['backend', 'devops-infra', 'data-ml', 'database', 'finance-payments', 'ai-engineering', 'productivity']
+
+function getFiles(dir, ext = '.md') {
+  const results = []
+  if (!fs.existsSync(dir)) return results
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name)
+    if (entry.isDirectory()) results.push(...getFiles(full, ext))
+    else if (entry.name.endsWith(ext)) results.push(full)
+  }
+  return results
+}
+
+function relPath(full) {
+  return full.replace(ROOT + '/', '')
+}
+
+function isTranslation(filepath) {
+  return LANGS.some(l => filepath.includes(`/${l}/`))
+}
+
+function getLang(filepath) {
+  for (const l of LANGS) {
+    if (filepath.includes(`/${l}/`)) return l
+  }
+  return 'en'
+}
+
+function readTitle(filepath) {
+  try {
+    const first = fs.readFileSync(filepath, 'utf-8').split('\n').find(l => l.startsWith('# '))
+    return first ? first.replace(/^# /, '').trim() : path.basename(filepath, '.md')
+  } catch {
+    return path.basename(filepath, '.md')
+  }
+}
+
+const index = {
+  version: require(path.join(ROOT, 'package.json')).version,
+  generated: new Date().toISOString(),
+  skills: [],
+  agents: [],
+  hooks: [],
+  rules: [],
+  workflows: [],
+  prompts: [],
+  guides: [],
+}
+
+// Skills
+for (const cat of SKILL_CATEGORIES) {
+  const catDir = path.join(ROOT, 'skills', cat)
+  for (const file of getFiles(catDir)) {
+    const rel = relPath(file)
+    const lang = getLang(rel)
+    const slug = rel.replace(/^skills\//, '').replace(/\.md$/, '').replace(/\/(fr|de|nl|es)\//, '/')
+    index.skills.push({
+      id: slug,
+      category: cat,
+      lang,
+      title: readTitle(file),
+      file: rel,
+    })
+  }
+}
+
+// Agents
+for (const file of getFiles(path.join(ROOT, 'agents'))) {
+  const rel = relPath(file)
+  const lang = getLang(rel)
+  const slug = rel.replace(/^agents\//, '').replace(/\.md$/, '').replace(/\/(fr|de|nl|es)\//, '/')
+  index.agents.push({ id: slug, lang, title: readTitle(file), file: rel })
+}
+
+// Hooks (md docs)
+for (const file of getFiles(path.join(ROOT, 'hooks'))) {
+  const rel = relPath(file)
+  const cat = rel.split('/')[1]
+  const slug = path.basename(file, '.md')
+  index.hooks.push({ id: `${cat}/${slug}`, category: cat, title: readTitle(file), file: rel })
+}
+
+// Rules
+for (const file of getFiles(path.join(ROOT, 'rules'))) {
+  const rel = relPath(file)
+  const lang = getLang(rel)
+  const slug = rel.replace(/^rules\//, '').replace(/\.md$/, '').replace(/\/(fr|de|nl|es)\//, '/')
+  index.rules.push({ id: slug, lang, title: readTitle(file), file: rel })
+}
+
+// Workflows
+for (const file of getFiles(path.join(ROOT, 'workflows'))) {
+  const rel = relPath(file)
+  const lang = getLang(rel)
+  const slug = path.basename(file, '.md')
+  index.workflows.push({ id: slug, lang, title: readTitle(file), file: rel })
+}
+
+// Prompts
+for (const file of getFiles(path.join(ROOT, 'prompts'))) {
+  const rel = relPath(file)
+  const lang = getLang(rel)
+  const cat = rel.split('/')[1]
+  const slug = `${cat}/${path.basename(file, '.md')}`
+  index.prompts.push({ id: slug.replace(/\/(fr|de|nl|es)\//, '/'), category: cat, lang, title: readTitle(file), file: rel })
+}
+
+// Guides
+for (const file of getFiles(path.join(ROOT, 'guides'))) {
+  const rel = relPath(file)
+  const lang = getLang(rel)
+  const slug = path.basename(file, '.md')
+  index.guides.push({ id: slug, lang, title: readTitle(file), file: rel })
+}
+
+// Summary counts (English only)
+const en = (arr) => arr.filter(i => i.lang === 'en' || !i.lang)
+index.summary = {
+  skills: en(index.skills).length,
+  agents: en(index.agents).length,
+  hooks: index.hooks.length,
+  rules: en(index.rules).length,
+  workflows: en(index.workflows).length,
+  prompts: en(index.prompts).length,
+  guides: en(index.guides).length,
+  languages: ['en', ...LANGS],
+}
+
+const outPath = path.join(ROOT, 'index.json')
+fs.writeFileSync(outPath, JSON.stringify(index, null, 2) + '\n')
+console.log(`Generated index.json — ${index.summary.skills} skills, ${index.summary.agents} agents, ${index.summary.hooks} hooks`)

package/skills/backend/java/de/spring-boot.md

@@ -0,0 +1,333 @@
+> 🇩🇪 Deutsche Version. [Englische Version](../spring-boot.md).
+
+# Spring Boot Skill
+
+## Wann aktivieren
+- Aufbau einer Spring Boot REST API oder eines Microservices
+- Einrichtung von Spring Data JPA mit Hibernate und PostgreSQL/MySQL
+- Konfiguration von Spring Security (JWT, OAuth2, sitzungsbasierte Authentifizierung)
+- Schreiben von Spring Boot Tests (Unit-Tests mit Mockito, Integrationstests mit TestRestTemplate oder MockMvc)
+- Einrichtung von Spring Cloud (Service Discovery, Config Server, API Gateway)
+- Implementierung asynchroner Verarbeitung mit `@Async` oder Spring Events
+- Konfiguration von Profilen, Properties und externalisierter Konfiguration
+- Schreiben benutzerdefinierter Spring Boot Starters oder Auto-Konfigurationen
+
+## Wann NICHT verwenden
+- Quarkus- oder Micronaut-Projekte — unterschiedliche Dependency-Injection- und Konfigurationsmodelle
+- Reines Java ohne Spring — der Overhead ist für einfache Skripte nicht gerechtfertigt
+- Android-Projekte — vollständig anderes Ökosystem
+- Jakarta EE/WildFly — anderes Application-Server-Modell
+
+## Anweisungen
+
+### Projektstruktur
+```
+src/
+├── main/
+│   ├── java/com/example/app/
+│   │   ├── AppApplication.java         # @SpringBootApplication entry point
+│   │   ├── config/                     # @Configuration beans
+│   │   ├── controller/                 # @RestController — HTTP layer only
+│   │   ├── service/                    # Business logic — @Service
+│   │   ├── repository/                 # @Repository — data access
+│   │   ├── domain/                     # @Entity models
+│   │   ├── dto/                        # Request/response shapes (records)
+│   │   ├── exception/                  # @ControllerAdvice error handling
+│   │   └── security/                   # Security config and filters
+│   └── resources/
+│       ├── application.yml             # Base config
+│       ├── application-dev.yml         # Dev overrides
+│       └── application-prod.yml        # Prod overrides
+└── test/
+    └── java/com/example/app/
+        ├── controller/                 # MockMvc / @WebMvcTest
+        ├── service/                    # Unit tests with Mockito
+        └── integration/               # @SpringBootTest full context
+```
+
+### Anwendungs-Einstiegspunkt
+```java
+@SpringBootApplication
+public class AppApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(AppApplication.class, args);
+    }
+}
+```
+
+### application.yml Struktur
+```yaml
+spring:
+  application:
+    name: my-service
+  datasource:
+    url: ${DATABASE_URL}
+    username: ${DB_USER}
+    password: ${DB_PASSWORD}
+  jpa:
+    hibernate:
+      ddl-auto: validate         # Never 'create' or 'update' in production
+    show-sql: false
+    properties:
+      hibernate:
+        format_sql: true
+
+server:
+  port: ${PORT:8080}
+
+# Custom properties — always use @ConfigurationProperties, never @Value for groups
+app:
+  jwt:
+    secret: ${JWT_SECRET}
+    expiration-ms: 86400000
+```
+
+### Entity und Repository
+```java
+// domain/User.java
+@Entity
+@Table(name = "users")
+public class User {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false, unique = true, length = 320)
+    private String email;
+
+    @Column(nullable = false)
+    private String passwordHash;
+
+    @CreationTimestamp
+    @Column(updatable = false)
+    private Instant createdAt;
+
+    // No-arg constructor required by JPA
+    protected User() {}
+
+    public User(String email, String passwordHash) {
+        this.email = email;
+        this.passwordHash = passwordHash;
+    }
+    // getters only — no setters on entities
+}
+
+// repository/UserRepository.java
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByEmail(String email);
+    boolean existsByEmail(String email);
+
+    // JPQL for complex queries
+    @Query("SELECT u FROM User u WHERE u.createdAt > :since")
+    List<User> findRecentUsers(@Param("since") Instant since);
+}
+```
+
+### Service-Schicht
+```java
+@Service
+@Transactional(readOnly = true)   // Default read-only; override for writes
+public class UserService {
+    private final UserRepository userRepo;
+    private final PasswordEncoder passwordEncoder;
+
+    public UserService(UserRepository userRepo, PasswordEncoder passwordEncoder) {
+        this.userRepo = userRepo;
+        this.passwordEncoder = passwordEncoder;
+    }
+
+    @Transactional   // Override: this method writes
+    public UserDto createUser(CreateUserRequest request) {
+        if (userRepo.existsByEmail(request.email())) {
+            throw new ConflictException("Email already in use");
+        }
+        User user = new User(request.email(), passwordEncoder.encode(request.password()));
+        return UserDto.from(userRepo.save(user));
+    }
+
+    public UserDto getById(Long id) {
+        return userRepo.findById(id)
+            .map(UserDto::from)
+            .orElseThrow(() -> new NotFoundException("User " + id + " not found"));
+    }
+}
+```
+
+### Controller-Schicht
+```java
+@RestController
+@RequestMapping("/api/v1/users")
+@Validated
+public class UserController {
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public UserDto createUser(@RequestBody @Valid CreateUserRequest request) {
+        return userService.createUser(request);
+    }
+
+    @GetMapping("/{id}")
+    public UserDto getUser(@PathVariable Long id) {
+        return userService.getById(id);
+    }
+
+    @GetMapping
+    public Page<UserDto> listUsers(Pageable pageable) {
+        return userService.findAll(pageable);
+    }
+}
+```
+
+### DTOs mit Records
+```java
+// dto/CreateUserRequest.java
+public record CreateUserRequest(
+    @NotBlank @Email String email,
+    @NotBlank @Size(min = 8) String password
+) {}
+
+// dto/UserDto.java
+public record UserDto(Long id, String email, Instant createdAt) {
+    public static UserDto from(User user) {
+        return new UserDto(user.getId(), user.getEmail(), user.getCreatedAt());
+    }
+}
+```
+
+### Globaler Exception-Handler
+```java
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(NotFoundException.class)
+    @ResponseStatus(HttpStatus.NOT_FOUND)
+    public ProblemDetail handleNotFound(NotFoundException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
+    }
+
+    @ExceptionHandler(ConflictException.class)
+    @ResponseStatus(HttpStatus.CONFLICT)
+    public ProblemDetail handleConflict(ConflictException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.CONFLICT, ex.getMessage());
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public ProblemDetail handleValidation(MethodArgumentNotValidException ex) {
+        var detail = ProblemDetail.forStatusAndDetail(HttpStatus.BAD_REQUEST, "Validation failed");
+        detail.setProperty("errors", ex.getBindingResult().getFieldErrors().stream()
+            .map(e -> e.getField() + ": " + e.getDefaultMessage())
+            .toList());
+        return detail;
+    }
+}
+```
+
+### Spring Security — JWT
+```java
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http, JwtAuthFilter jwtFilter) throws Exception {
+        return http
+            .csrf(AbstractHttpConfigurer::disable)
+            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            .authorizeHttpRequests(auth -> auth
+                .requestMatchers("/api/v1/auth/**", "/actuator/health").permitAll()
+                .anyRequest().authenticated()
+            )
+            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
+            .build();
+    }
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}
+```
+
+### Tests
+```java
+// @WebMvcTest — Controller-Slice-Test (kein vollständiger Kontext)
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+    @Autowired MockMvc mockMvc;
+    @MockitoBean UserService userService;     // Spring Boot 3.4+: @MockitoBean
+
+    @Test
+    void createUser_returnsCreated() throws Exception {
+        given(userService.createUser(any())).willReturn(new UserDto(1L, "a@b.com", Instant.now()));
+
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("""{"email":"a@b.com","password":"password123"}"""))
+            .andExpect(status().isCreated())
+            .andExpect(jsonPath("$.email").value("a@b.com"));
+    }
+}
+
+// @SpringBootTest — vollständiger Integrationstest
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@Transactional
+class UserServiceIntegrationTest {
+    @Autowired UserService userService;
+
+    @Test
+    void createUser_persistsToDatabase() {
+        var user = userService.createUser(new CreateUserRequest("a@b.com", "password123"));
+        assertThat(user.email()).isEqualTo("a@b.com");
+        assertThat(user.id()).isNotNull();
+    }
+}
+```
+
+### Spring Cloud Muster
+```yaml
+# Service discovery with Eureka
+spring:
+  application:
+    name: user-service
+eureka:
+  client:
+    service-url:
+      defaultZone: http://eureka-server:8761/eureka/
+
+# Config server client
+spring:
+  config:
+    import: configserver:http://config-server:8888
+```
+
+```java
+// Feign client for inter-service calls
+@FeignClient(name = "order-service")
+public interface OrderClient {
+    @GetMapping("/api/v1/orders/user/{userId}")
+    List<OrderDto> getOrdersByUser(@PathVariable Long userId);
+}
+```
+
+## Beispiel
+
+**Nutzer:** Erstelle eine Spring Boot REST API für einen Produktkatalog mit CRUD-Endpunkten, PostgreSQL über JPA, Bean-Validierung, globalem Fehler-Handling und einem `@WebMvcTest` für den GET-Endpunkt.
+
+**Erwartete Ausgabe:**
+- `Product` Entity — `id`, `name`, `price` (BigDecimal), `stock`, `createdAt`
+- `ProductDto` Record + `CreateProductRequest` Record mit `@NotBlank` / `@Positive` Validierung
+- `ProductRepository extends JpaRepository<Product, Long>`
+- `ProductService` — `@Transactional(readOnly = true)` auf Klassenebene, `@Transactional` für Schreiboperationen
+- `ProductController` — CRUD unter `/api/v1/products`, `Pageable` auf GET-Liste
+- `GlobalExceptionHandler` — `NotFoundException` → 404, `MethodArgumentNotValidException` → 400 mit Feldfehlern
+- `ProductControllerTest` mit `@WebMvcTest` + `@MockitoBean ProductService`
+
+---
+
+> **Arbeite mit uns:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir entwickeln KI-Produkte und B2B-Lösungen mit Entwickler-Communities. [uitbreiden.com](https://uitbreiden.com/)