@the-bearded-bear/claude-craft 3.1.2 → 3.3.1-next.f4f0d1e

package/Dev/i18n/de/Angular/CLAUDE.md.template

@@ -0,0 +1,49 @@
+# Angular Project - Claude Instructions
+
+## Overview
+
+This is an Angular {{ANGULAR_VERSION}} project using standalone components and signals for reactive state management.
+
+## Key Principles
+
+1. **Standalone Components**: All components must be standalone (no NgModules)
+2. **Signals First**: Use Angular Signals for reactive state
+3. **OnPush Strategy**: All components use ChangeDetectionStrategy.OnPush
+4. **Type Safety**: Strict TypeScript mode enabled
+5. **Modern Control Flow**: Use @if, @for, @switch (not *ngIf, *ngFor)
+
+## Project Structure
+
+```
+src/app/
+├── core/           # Singleton services, guards, interceptors
+├── shared/         # Reusable components, pipes, directives
+├── features/       # Business features (domain-driven)
+├── layout/         # Layout components (header, sidebar, shell)
+└── app.routes.ts   # Root routing
+```
+
+## Code Generation
+
+When generating components:
+```bash
+ng generate component features/{{feature}}/components/{{name}} --standalone
+```
+
+## Testing
+
+- Unit tests: Vitest or Jest with Angular Testing Library
+- E2E tests: Cypress
+- Minimum coverage: 80%
+
+## Styling
+
+{{STYLING_INSTRUCTIONS}}
+
+## State Management
+
+{{STATE_MANAGEMENT_INSTRUCTIONS}}
+
+## Additional Instructions
+
+{{CUSTOM_INSTRUCTIONS}}

package/Dev/i18n/de/Angular/agents/angular-reviewer.md

@@ -0,0 +1,213 @@
+# Angular Code Reviewer Agent
+
+You are an expert Angular code reviewer with deep knowledge of Angular best practices, TypeScript, RxJS, and modern web development patterns.
+
+## Your Role
+
+Review Angular code and provide constructive feedback on:
+- Code quality and maintainability
+- Angular best practices compliance
+- Performance optimization
+- Security vulnerabilities
+- Testing coverage
+
+## Review Criteria
+
+### 1. Standalone Components
+
+```typescript
+// ✅ Good
+@Component({
+  selector: 'app-user-profile',
+  standalone: true,
+  imports: [CommonModule],
+  changeDetection: ChangeDetectionStrategy.OnPush
+})
+
+// ❌ Bad - Not standalone, no OnPush
+@Component({
+  selector: 'app-user-profile'
+})
+```
+
+### 2. Signals Usage
+
+```typescript
+// ✅ Good - Using signals
+count = signal(0);
+doubleCount = computed(() => this.count() * 2);
+
+// ❌ Bad - Using BehaviorSubject for local state
+count$ = new BehaviorSubject(0);
+```
+
+### 3. Modern Control Flow
+
+```typescript
+// ✅ Good - @if, @for, @switch
+@if (loading()) {
+  <spinner />
+}
+@for (item of items(); track item.id) {
+  <item-card [item]="item" />
+}
+
+// ❌ Bad - Legacy *ngIf, *ngFor
+*ngIf="loading"
+*ngFor="let item of items"
+```
+
+### 4. Dependency Injection
+
+```typescript
+// ✅ Good - inject() function
+private readonly service = inject(MyService);
+
+// ⚠️ Acceptable but verbose
+constructor(private service: MyService) {}
+```
+
+### 5. Subscription Management
+
+```typescript
+// ✅ Good - takeUntilDestroyed
+private destroyRef = inject(DestroyRef);
+
+ngOnInit() {
+  this.data$.pipe(
+    takeUntilDestroyed(this.destroyRef)
+  ).subscribe();
+}
+
+// ❌ Bad - No cleanup
+ngOnInit() {
+  this.data$.subscribe(); // Memory leak!
+}
+```
+
+### 6. Error Handling
+
+```typescript
+// ✅ Good - Proper error handling
+loadData() {
+  this.loading.set(true);
+  this.api.getData().subscribe({
+    next: data => this.data.set(data),
+    error: err => this.error.set(err.message),
+    complete: () => this.loading.set(false)
+  });
+}
+
+// ❌ Bad - No error handling
+loadData() {
+  this.api.getData().subscribe(data => this.data = data);
+}
+```
+
+### 7. Type Safety
+
+```typescript
+// ✅ Good - Typed forms
+interface UserForm {
+  name: FormControl<string>;
+  email: FormControl<string>;
+}
+
+form = new FormGroup<UserForm>({...});
+
+// ❌ Bad - Untyped
+form = new FormGroup({
+  name: new FormControl(''),
+  email: new FormControl('')
+});
+```
+
+## Review Output Format
+
+```markdown
+## Code Review: {File/Component Name}
+
+### Summary
+Brief overview of the code quality and main findings.
+
+### Score: X/100
+
+### Strengths
+- ✅ Point 1
+- ✅ Point 2
+
+### Issues Found
+
+#### Critical (Must Fix)
+- 🔴 Issue description
+  - File: `path/to/file.ts:line`
+  - Suggested fix: ...
+
+#### Major (Should Fix)
+- 🟠 Issue description
+  - File: `path/to/file.ts:line`
+  - Suggested fix: ...
+
+#### Minor (Consider Fixing)
+- 🟡 Issue description
+  - File: `path/to/file.ts:line`
+  - Suggested fix: ...
+
+### Recommendations
+1. Recommendation 1
+2. Recommendation 2
+
+### Code Suggestions
+
+```typescript
+// Before
+{code before}
+
+// After
+{code after}
+```
+```
+
+## Review Checklist
+
+### Architecture
+- [ ] Correct folder structure
+- [ ] No circular dependencies
+- [ ] Smart/Dumb pattern followed
+- [ ] Lazy loading implemented
+
+### Components
+- [ ] Standalone components
+- [ ] OnPush change detection
+- [ ] Signals for state
+- [ ] Modern control flow
+
+### Services
+- [ ] Single responsibility
+- [ ] Proper error handling
+- [ ] Subscription management
+- [ ] Injectable configuration
+
+### Security
+- [ ] No bypassSecurityTrust with user input
+- [ ] Input validation
+- [ ] No sensitive data exposure
+
+### Testing
+- [ ] Test coverage adequate
+- [ ] Tests follow AAA pattern
+- [ ] Edge cases covered
+
+### Performance
+- [ ] trackBy on lists
+- [ ] No memory leaks
+- [ ] Lazy loading used
+
+## Severity Guidelines
+
+| Severity | Criteria |
+|----------|----------|
+| Critical | Security vulnerabilities, memory leaks, breaking bugs |
+| Major | Best practice violations, performance issues |
+| Minor | Style issues, documentation gaps |
+| Info | Suggestions for improvement |

package/Dev/i18n/de/Angular/checklists/new-feature.md

@@ -0,0 +1,125 @@
+# Angular New Feature Checklist
+
+## Before Starting
+
+- [ ] Requirements are clear and documented
+- [ ] Feature scope is defined
+- [ ] Design/mockups available (if UI)
+- [ ] API contract defined (if backend integration)
+
+## Architecture
+
+- [ ] Feature folder created: `src/app/features/{feature}/`
+- [ ] Correct folder structure:
+  ```
+  features/{feature}/
+  ├── components/
+  ├── services/
+  ├── store/
+  └── {feature}.routes.ts
+  ```
+- [ ] No cross-feature dependencies
+
+## Components
+
+- [ ] All components are standalone
+- [ ] All components use OnPush
+- [ ] Smart/Dumb pattern followed
+- [ ] Signal inputs used (`input()`, `input.required()`)
+- [ ] Signals used for local state
+- [ ] Computed signals for derived state
+
+## State Management
+
+- [ ] Store service created if needed
+- [ ] State is immutable
+- [ ] Selectors are computed signals
+- [ ] Actions update state correctly
+
+## Routing
+
+- [ ] Routes lazy loaded
+- [ ] Guards added if protected
+- [ ] Route params handled correctly
+
+## Forms
+
+- [ ] Typed reactive forms used
+- [ ] Validation implemented
+- [ ] Error messages displayed
+- [ ] Form accessibility (labels, ARIA)
+
+## API Integration
+
+- [ ] API service created
+- [ ] Error handling implemented
+- [ ] Loading states managed
+- [ ] Retry logic if needed
+
+## Testing
+
+- [ ] Unit tests for components
+- [ ] Unit tests for services
+- [ ] Unit tests for store
+- [ ] Integration tests if complex
+- [ ] Coverage > 80%
+
+## Accessibility
+
+- [ ] Semantic HTML used
+- [ ] ARIA labels where needed
+- [ ] Keyboard navigation works
+- [ ] Focus management correct
+- [ ] Color contrast sufficient
+
+## Performance
+
+- [ ] trackBy on all @for loops
+- [ ] Lazy loading used
+- [ ] No unnecessary re-renders
+- [ ] Bundle size checked
+
+## Documentation
+
+- [ ] README updated if public API
+- [ ] Complex logic documented
+- [ ] Component inputs/outputs documented
+
+## Code Quality
+
+- [ ] No TypeScript errors
+- [ ] No ESLint errors
+- [ ] Code formatted
+- [ ] No console.log in final code
+
+## Before PR
+
+- [ ] All tests pass
+- [ ] Build succeeds
+- [ ] No security issues
+- [ ] Code reviewed by self
+- [ ] PR description written
+
+## PR Description Template
+
+```markdown
+## Summary
+Brief description of the feature
+
+## Changes
+- Component A: Added user profile display
+- Service B: Created API integration
+- Store C: Added state management
+
+## Testing
+- [ ] Unit tests added
+- [ ] Manual testing completed
+
+## Screenshots
+(if UI changes)
+
+## Checklist
+- [ ] Tests pass
+- [ ] Build succeeds
+- [ ] Documentation updated
+```

package/Dev/i18n/de/Angular/checklists/pre-commit.md

@@ -0,0 +1,77 @@
+# Angular Pre-Commit Checklist
+
+## Before Committing
+
+Run through this checklist before committing code changes.
+
+### 1. Code Quality
+
+- [ ] No TypeScript errors: `npx tsc --noEmit`
+- [ ] No ESLint errors: `ng lint`
+- [ ] Code is formatted: `npm run format:check`
+- [ ] No console.log statements in production code
+
+### 2. Tests
+
+- [ ] All tests pass: `npm run test`
+- [ ] New code has tests
+- [ ] Coverage maintained: `npm run test:coverage`
+
+### 3. Build
+
+- [ ] Build succeeds: `ng build`
+- [ ] No bundle size regressions
+
+### 4. Angular Standards
+
+- [ ] Components are standalone
+- [ ] Components use OnPush change detection
+- [ ] Signals used for local state
+- [ ] Modern control flow (@if, @for)
+- [ ] trackBy used in all @for loops
+
+### 5. Security
+
+- [ ] No sensitive data in code
+- [ ] No bypassSecurityTrust* with user input
+- [ ] Input validation on forms
+- [ ] Routes properly protected
+
+### 6. Documentation
+
+- [ ] Complex logic documented
+- [ ] Public API has JSDoc comments
+- [ ] README updated if needed
+
+## Quick Commands
+
+```bash
+# Run all checks
+npm run lint && npm run test && ng build
+
+# Fix formatting
+npm run format
+
+# Fix linting issues
+ng lint --fix
+```
+
+## Commit Message Format
+
+```
+<type>(<scope>): <subject>
+
+feat(users): add user profile component
+fix(auth): handle token refresh error
+docs(readme): update installation instructions
+```
+
+### Types
+
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation
+- `style`: Formatting
+- `refactor`: Code restructuring
+- `test`: Adding tests
+- `chore`: Maintenance

package/Dev/i18n/de/Angular/commands/check-architecture.md

@@ -0,0 +1,261 @@
+---
+description: Angular Architecture Review
+---
+
+# Angular Architecture Review
+
+Analyze the Angular project architecture and provide recommendations for improvement.
+
+## What This Command Does
+
+1. **Structure Analysis**
+   - Folder organization
+   - Feature modularity
+   - Dependency flow
+   - Layer separation
+
+2. **Pattern Verification**
+   - Smart/Dumb components
+   - Service patterns
+   - State management
+   - Routing structure
+
+3. **Generated Report**
+   - Architecture score
+   - Violations found
+   - Improvement recommendations
+
+## Architecture Standards
+
+### 1. Folder Structure
+
+```
+✅ Expected Structure:
+src/app/
+├── core/                    # Singleton services, guards, interceptors
+│   ├── services/
+│   ├── guards/
+│   ├── interceptors/
+│   └── models/
+├── shared/                  # Reusable components, pipes, directives
+│   ├── components/
+│   ├── pipes/
+│   ├── directives/
+│   └── validators/
+├── features/                # Business features
+│   └── {feature}/
+│       ├── components/
+│       ├── services/
+│       ├── store/
+│       └── {feature}.routes.ts
+├── layout/                  # Layout components
+│   ├── header/
+│   ├── sidebar/
+│   └── shell/
+├── app.config.ts
+├── app.component.ts
+└── app.routes.ts
+```
+
+### 2. Dependency Rules
+
+```
+✅ Allowed Dependencies:
+- features → core, shared
+- shared → core (types only)
+- core → (external only)
+
+❌ Forbidden Dependencies:
+- core → features
+- core → shared (components)
+- shared → features
+- features → features (cross-feature)
+```
+
+### 3. Smart/Dumb Pattern
+
+```typescript
+// ✅ Container (Smart) Component
+// - Injects services
+// - Manages state
+// - Handles side effects
+@Component({
+  selector: 'app-user-list-container',
+  template: `
+    <app-user-list
+      [users]="users()"
+      [loading]="loading()"
+      (userSelected)="onSelect($event)"
+    />
+  `
+})
+export class UserListContainerComponent {
+  private usersService = inject(UsersService);
+  users = this.usersService.users;
+  loading = this.usersService.loading;
+}
+
+// ✅ Presenter (Dumb) Component
+// - Only @Input/@Output
+// - No service injection
+// - Pure display logic
+@Component({
+  selector: 'app-user-list',
+  changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class UserListComponent {
+  @Input({ required: true }) users!: User[];
+  @Input() loading = false;
+  @Output() userSelected = new EventEmitter<string>();
+}
+```
+
+### 4. Service Layer
+
+```typescript
+// ✅ API Service (Data access)
+@Injectable({ providedIn: 'root' })
+export class UsersApiService {
+  private http = inject(HttpClient);
+
+  getUsers(): Observable<User[]> {
+    return this.http.get<User[]>('/api/users');
+  }
+}
+
+// ✅ Store Service (State management)
+@Injectable({ providedIn: 'root' })
+export class UsersStore {
+  private state = signal<UsersState>(initialState);
+
+  users = computed(() => this.state().users);
+  loading = computed(() => this.state().loading);
+
+  setUsers(users: User[]): void {
+    this.state.update(s => ({ ...s, users }));
+  }
+}
+
+// ✅ Facade Service (Orchestration)
+@Injectable({ providedIn: 'root' })
+export class UsersService {
+  private api = inject(UsersApiService);
+  private store = inject(UsersStore);
+
+  users = this.store.users;
+  loading = this.store.loading;
+
+  loadUsers(): void {
+    this.store.setLoading(true);
+    this.api.getUsers().subscribe({
+      next: users => this.store.setUsers(users),
+      error: err => this.store.setError(err.message)
+    });
+  }
+}
+```
+
+### 5. Routing Structure
+
+```typescript
+// ✅ Root routes with lazy loading
+export const routes: Routes = [
+  {
+    path: '',
+    loadComponent: () => import('./layout/shell/shell.component'),
+    children: [
+      {
+        path: 'users',
+        loadChildren: () => import('./features/users/users.routes'),
+        canActivate: [authGuard]
+      }
+    ]
+  }
+];
+
+// ✅ Feature routes
+export const USERS_ROUTES: Routes = [
+  { path: '', loadComponent: () => import('./user-list.component') },
+  { path: ':id', loadComponent: () => import('./user-detail.component') }
+];
+```
+
+## Scoring Criteria
+
+| Category | Weight | Criteria |
+|----------|--------|----------|
+| Folder Structure | 20% | Correct organization |
+| Dependency Flow | 20% | No circular/forbidden deps |
+| Smart/Dumb Pattern | 15% | Proper separation |
+| Service Layer | 15% | API/Store/Facade pattern |
+| Lazy Loading | 15% | Routes properly lazy loaded |
+| Feature Isolation | 15% | No cross-feature imports |
+
+## Output Format
+
+```
+══════════════════════════════════════════════════════════════
+ANGULAR ARCHITECTURE REVIEW
+══════════════════════════════════════════════════════════════
+
+📊 SCORE: 78/100
+
+📁 FOLDER STRUCTURE: 90/100
+──────────────────────────────────────────────────────────────
+✅ core/ properly organized
+✅ shared/ properly organized
+✅ features/ properly organized
+⚠️ Missing layout/ folder
+
+🔗 DEPENDENCY FLOW: 70/100
+──────────────────────────────────────────────────────────────
+✅ features → core: OK
+✅ features → shared: OK
+❌ Forbidden: features/users → features/auth
+   - src/app/features/users/user-profile.component.ts:5
+     imports { AuthService } from '../auth/services'
+
+🧩 SMART/DUMB PATTERN: 80/100
+──────────────────────────────────────────────────────────────
+✅ 16/20 components follow pattern
+⚠️ 4 components mix concerns:
+   - src/app/features/users/user-list.component.ts
+     Smart component with display logic
+
+🔧 SERVICE LAYER: 75/100
+──────────────────────────────────────────────────────────────
+✅ API services: OK
+✅ Store services: OK
+⚠️ Missing facade pattern in:
+   - features/auth/
+   - features/dashboard/
+
+🚀 LAZY LOADING: 85/100
+──────────────────────────────────────────────────────────────
+✅ Feature routes lazy loaded
+⚠️ Shared components not lazy loaded
+
+📋 RECOMMENDATIONS
+──────────────────────────────────────────────────────────────
+1. Create layout/ folder for Header, Sidebar, Shell
+2. Remove cross-feature import (users → auth)
+   → Move AuthService to core/
+3. Separate smart/dumb components in user-list
+4. Add facade services for auth and dashboard features
+5. Consider lazy loading large shared components
+
+══════════════════════════════════════════════════════════════
+```
+
+## Architecture Checklist
+
+- [ ] Correct folder structure (core/shared/features/layout)
+- [ ] No forbidden dependencies
+- [ ] No cross-feature imports
+- [ ] Smart/Dumb pattern followed
+- [ ] Service layer properly structured
+- [ ] All feature routes lazy loaded
+- [ ] Standalone components used
+- [ ] Guards and interceptors in core/
+- [ ] Reusable components in shared/
+- [ ] Feature-specific code in features/