@gherk/reactive-architecture 1.0.0

package/dist/knowledge/folder-structure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder-structure.js","sourceRoot":"","sources":["../../src/knowledge/folder-structure.ts"],"names":[],"mappings":"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"}

package/dist/knowledge/philosophy.d.ts

@@ -0,0 +1,11 @@
+export declare const PHILOSOPHY_OVERVIEW = "\n# Reactive Frontend Architecture Philosophy\n\n## Core Principle\nEvery frontend feature MUST be structured following **three clearly separated layers**:\n\n```\nComponent \u2192 Store \u2192 Service\n   (UI)    (State)  (Data Access)\n```\n\nThis is a **strict, non-negotiable pattern**. It applies to EVERY feature, in EVERY framework (Angular, React, Vue, Svelte, or any other). The technology changes, the philosophy does NOT.\n\n## Why This Pattern?\n\n1. **Predictability**: Data always flows in one direction. You always know where state lives and how it changes.\n2. **Testability**: Each layer can be tested in isolation. Components test rendering, stores test logic, services test data access.\n3. **Reusability**: Services can be shared across stores. Stores can be shared across components. Components are self-contained.\n4. **Scalability**: Adding features doesn't increase complexity because each feature follows the same pattern.\n5. **AI-Friendly**: When AI assistants follow this pattern consistently, the codebase remains coherent regardless of who (or what) writes the code.\n";
+export declare const COMPONENT_LAYER = "\n# Component Layer (UI / Presentation)\n\n## Responsibility\nThe component is **ONLY** responsible for:\n- Rendering UI based on state from the store\n- Capturing user interactions (clicks, input, navigation)\n- Dispatching actions/calls to the store\n- Presentational logic ONLY (formatting dates, toggling CSS classes)\n\n## Rules\n\n### MUST\n- Read all data from the store (via selectors, signals, observables, or reactive primitives)\n- Delegate ALL side effects to the store (loading data, submitting forms, etc.)\n- Be as \"dumb\" as possible \u2014 a template with holes filled by the store\n- Handle only UI concerns: show/hide, enable/disable, format display values\n\n### MUST NOT\n- Call HTTP/fetch/axios directly \u2014 NEVER\n- Contain business logic (validation rules, calculations, transformations)\n- Hold application state in local variables (only ephemeral UI state like \"is dropdown open\")\n- Know about the data access layer (services) \u2014 it only knows the store\n- Import or inject services directly\n\n## Ephemeral UI State (The Exception)\nComponents CAN hold purely ephemeral UI state that has no business meaning:\n- `isDropdownOpen`\n- `currentTabIndex`\n- `isModalVisible`\n\nThis state dies with the component and has no impact on application logic.\n\n## Mental Model\n> Think of the component as a **TV screen**: it displays what the store tells it, and it has a remote control (user interactions) that sends commands to the store. The TV never fetches channels itself.\n";
+export declare const STORE_LAYER = "\n# Store Layer (State Management / Business Logic)\n\n## Responsibility\nThe store is the **single source of truth** for a feature's state. It:\n- Holds the feature state (data, loading, error, filters, pagination, etc.)\n- Exposes reactive selectors/computed values for components to consume\n- Contains business logic (when to load, how to transform, validation orchestration)\n- Orchestrates service calls (calls the service, handles the response, updates state)\n\n## Rules\n\n### MUST\n- Be the ONLY place where feature state lives\n- Expose state as reactive primitives (signals, observables, reactive refs \u2014 depending on framework)\n- Handle loading/error/success states explicitly\n- Call services for any data access needs\n- Be the orchestrator: component asks \u2192 store decides \u2192 service fetches \u2192 store updates \u2192 component reacts\n\n### MUST NOT\n- Make HTTP calls directly \u2014 delegate to services\n- Know about the DOM or UI rendering\n- Depend on component lifecycle (it should be independent)\n- Import component code\n\n## State Shape Convention\nEvery feature store should manage at minimum:\n```typescript\n{\n  data: T | T[];           // The actual feature data\n  loading: boolean;        // Is data being fetched/submitted?\n  error: string | null;    // Error message if something failed\n  loaded: boolean;         // Has data been loaded at least once?\n}\n```\n\nAdditional state as needed:\n- `filters`, `sorting`, `pagination` for list features\n- `selectedItem` for detail views\n- `formData`, `formErrors` for form features\n\n## Mental Model\n> Think of the store as the **brain**: it knows the current state of everything, decides what to do when the component asks for something, and tells the service to go fetch or send data. It then updates its knowledge based on what comes back.\n";
+export declare const SERVICE_LAYER = "\n# Service Layer (Data Access)\n\n## Responsibility\nThe service is a **pure data access layer**. It:\n- Makes HTTP requests (GET, POST, PUT, DELETE)\n- Handles WebSocket connections\n- Accesses localStorage/sessionStorage\n- Interacts with any external data source\n\n## Rules\n\n### MUST\n- Be stateless \u2014 no internal state, no caching (that's the store's job)\n- Return data in a clean format (observables, promises, or the framework's preferred async primitive)\n- Handle request configuration (headers, base URL, interceptors)\n- Map API responses to domain models/interfaces if needed\n- Be reusable across different stores\n\n### MUST NOT\n- Hold state \u2014 NEVER\n- Contain business logic (no \"if user is admin, do X\")\n- Know about components or stores (it's a pure utility)\n- Handle loading/error state (that's the store's job)\n- Transform data for display purposes (that's the component's job)\n\n## Service Method Convention\n```typescript\n// GOOD: Clean, simple, one job\ngetUsers(): Observable<User[]> | Promise<User[]>\ngetUserById(id: string): Observable<User> | Promise<User>\ncreateUser(data: CreateUserDto): Observable<User> | Promise<User>\nupdateUser(id: string, data: UpdateUserDto): Observable<User> | Promise<User>\ndeleteUser(id: string): Observable<void> | Promise<void>\n\n// BAD: Doing too much\ngetUsersAndTransformForDisplay()  // \u274C Transformation is store/component job\ngetUsersIfNotCached()             // \u274C Caching is the store's job\ngetUsersAndSetLoading()           // \u274C Loading state is the store's job\n```\n\n## Mental Model\n> Think of the service as a **messenger/courier**: it goes out, gets or delivers the package, and comes back. It doesn't open the package, doesn't decide what to do with it, and doesn't remember what it delivered yesterday.\n";
+export declare const ANTI_PATTERNS = "\n# Anti-patterns \u2014 What NOT To Do\n\n## 1. HTTP in Components \u274C\n```typescript\n// \u274C WRONG: Component calling HTTP directly\nclass UserListComponent {\n  users = [];\n  async ngOnInit() {\n    this.users = await fetch('/api/users').then(r => r.json());\n  }\n}\n\n// \u2705 CORRECT: Component reads from store\nclass UserListComponent {\n  users = this.userStore.users;\n  constructor(private userStore: UserStore) {\n    this.userStore.loadUsers();\n  }\n}\n```\n\n## 2. Business Logic in Services \u274C\n```typescript\n// \u274C WRONG: Service deciding business rules\nclass UserService {\n  async getVisibleUsers() {\n    const users = await this.http.get('/users');\n    return users.filter(u => u.role !== 'admin' && u.isActive);\n  }\n}\n\n// \u2705 CORRECT: Service returns raw data, store filters\nclass UserService {\n  getUsers() { return this.http.get('/users'); }\n}\nclass UserStore {\n  visibleUsers = computed(() =>\n    this.users().filter(u => u.role !== 'admin' && u.isActive)\n  );\n}\n```\n\n## 3. State in Services \u274C\n```typescript\n// \u274C WRONG: Service holding state\nclass UserService {\n  private users: User[] = [];\n  private loading = false;\n\n  async loadUsers() {\n    this.loading = true;\n    this.users = await fetch('/api/users');\n    this.loading = false;\n  }\n}\n\n// \u2705 CORRECT: State lives in the store\nclass UserStore {\n  readonly users = signal<User[]>([]);\n  readonly loading = signal(false);\n\n  async loadUsers() {\n    this.loading.set(true);\n    const data = await this.userService.getUsers();\n    this.users.set(data);\n    this.loading.set(false);\n  }\n}\n```\n\n## 4. Component Holding Business State \u274C\n```typescript\n// \u274C WRONG: Component managing complex state\nclass UserListComponent {\n  users: User[] = [];\n  filteredUsers: User[] = [];\n  filters = { search: '', role: 'all' };\n  loading = false;\n  error = null;\n\n  applyFilters() { /* complex filtering */ }\n}\n\n// \u2705 CORRECT: Store manages state, component just reads\nclass UserListComponent {\n  users = this.store.filteredUsers;\n  loading = this.store.loading;\n  error = this.store.error;\n}\n```\n\n## 5. Store Accessing DOM \u274C\n```typescript\n// \u274C WRONG: Store manipulating DOM\nclass UserStore {\n  showSuccessMessage() {\n    document.getElementById('toast').style.display = 'block';\n  }\n}\n\n// \u2705 CORRECT: Store updates state, component reacts\nclass UserStore {\n  readonly notification = signal<string | null>(null);\n}\n// Component template reacts to notification signal\n```\n\n## 6. Skipping the Store \u274C\n```typescript\n// \u274C WRONG: Component calling service directly\nclass UserComponent {\n  constructor(private userService: UserService) {}\n  async save() {\n    await this.userService.createUser(this.formData);\n  }\n}\n\n// \u2705 CORRECT: Component goes through store\nclass UserComponent {\n  constructor(private userStore: UserStore) {}\n  save() {\n    this.userStore.createUser(this.formData);\n  }\n}\n```\n";
+export declare const FILE_STRUCTURE = "\n# File Structure Convention\n\nEvery feature should follow this directory structure:\n\n```\nsrc/\n\u251C\u2500\u2500 features/\n\u2502   \u2514\u2500\u2500 users/                    # Feature folder\n\u2502       \u251C\u2500\u2500 components/           # All components for this feature\n\u2502       \u2502   \u251C\u2500\u2500 user-list/\n\u2502       \u2502   \u2502   \u251C\u2500\u2500 user-list.component.ts\n\u2502       \u2502   \u2502   \u251C\u2500\u2500 user-list.component.html   # (if framework uses templates)\n\u2502       \u2502   \u2502   \u2514\u2500\u2500 user-list.component.css\n\u2502       \u2502   \u251C\u2500\u2500 user-detail/\n\u2502       \u2502   \u2502   \u2514\u2500\u2500 ...\n\u2502       \u2502   \u2514\u2500\u2500 user-form/\n\u2502       \u2502       \u2514\u2500\u2500 ...\n\u2502       \u251C\u2500\u2500 store/                # Feature store\n\u2502       \u2502   \u251C\u2500\u2500 user.store.ts\n\u2502       \u2502   \u2514\u2500\u2500 user.store.spec.ts\n\u2502       \u251C\u2500\u2500 services/             # Data access services\n\u2502       \u2502   \u251C\u2500\u2500 user.service.ts\n\u2502       \u2502   \u2514\u2500\u2500 user.service.spec.ts\n\u2502       \u251C\u2500\u2500 models/               # TypeScript interfaces & types\n\u2502       \u2502   \u2514\u2500\u2500 user.model.ts\n\u2502       \u2514\u2500\u2500 index.ts              # Public API barrel file\n\u251C\u2500\u2500 shared/                       # Cross-feature shared code\n\u2502   \u251C\u2500\u2500 components/               # Reusable UI components\n\u2502   \u251C\u2500\u2500 services/                 # Shared services (auth, http interceptor)\n\u2502   \u251C\u2500\u2500 stores/                   # Shared stores (auth, ui, notifications)\n\u2502   \u2514\u2500\u2500 models/                   # Shared interfaces & types\n\u2514\u2500\u2500 core/                         # App-wide singletons\n    \u251C\u2500\u2500 auth/\n    \u251C\u2500\u2500 layout/\n    \u2514\u2500\u2500 config/\n```\n\n## Naming Conventions\n- Feature folders: **kebab-case** (e.g., `user-management`)\n- Store files: `<feature>.store.ts`\n- Service files: `<feature>.service.ts`\n- Model files: `<feature>.model.ts`\n- Component files: `<component-name>.component.ts`\n- Test files: `<file>.spec.ts` or `<file>.test.ts`\n\n## Barrel Files (index.ts)\nEvery feature folder MUST have an `index.ts` that exports the public API:\n```typescript\n// features/users/index.ts\nexport { UserListComponent } from './components/user-list/user-list.component';\nexport { UserStore } from './store/user.store';\nexport { UserService } from './services/user.service';\nexport type { User, CreateUserDto } from './models/user.model';\n```\n";
+export declare const IMPLEMENTATION_FLOW = "\n# Implementation Flow \u2014 How to Build a Feature\n\nWhen implementing a new feature, ALWAYS follow this order:\n\n## Step 1: Define the Model\nCreate the TypeScript interfaces/types that represent the data:\n```typescript\n// models/user.model.ts\nexport interface User {\n  id: string;\n  name: string;\n  email: string;\n  role: 'admin' | 'user';\n  isActive: boolean;\n}\n\nexport interface CreateUserDto {\n  name: string;\n  email: string;\n  role: 'admin' | 'user';\n}\n```\n\n## Step 2: Build the Service\nCreate the data access layer (HTTP calls):\n```typescript\n// services/user.service.ts\n// Returns promises or observables, nothing more\n```\n\n## Step 3: Build the Store\nCreate the state management layer:\n```typescript\n// store/user.store.ts\n// Holds state, calls service, exposes reactive selectors\n```\n\n## Step 4: Build the Component\nCreate the UI that reads from the store:\n```typescript\n// components/user-list/user-list.component.ts\n// Reads from store, dispatches to store, renders UI\n```\n\n## Step 5: Write Tests\n- Service tests: Mock HTTP, verify requests\n- Store tests: Mock service, verify state transitions\n- Component tests: Mock store, verify rendering & interactions\n\n## Why This Order?\n- **Model first**: defines the contract between all layers\n- **Service second**: it has no dependencies, easiest to build and test\n- **Store third**: depends only on service, contains the logic\n- **Component last**: depends on store, is purely visual\n- **Tests alongside or after**: ensures each layer works correctly\n\nThis is a **bottom-up** approach that ensures you never build a layer without its dependency being ready.\n";
+export declare function getFullPhilosophy(): string;
+export declare function getSection(section: string): string | null;
+export declare const AVAILABLE_SECTIONS: string[];
+//# sourceMappingURL=philosophy.d.ts.map

package/dist/knowledge/philosophy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"philosophy.d.ts","sourceRoot":"","sources":["../../src/knowledge/philosophy.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,mBAAmB,+kCAoB/B,CAAC;AAEF,eAAO,MAAM,eAAe,0+CAmC3B,CAAC;AAEF,eAAO,MAAM,WAAW,2zDA2CvB,CAAC;AAEF,eAAO,MAAM,aAAa,gyDA2CzB,CAAC;AAEF,eAAO,MAAM,aAAa,y9FA8HzB,CAAC;AAEF,eAAO,MAAM,cAAc,4rFAuD1B,CAAC;AAEF,eAAO,MAAM,mBAAmB,6oDA0D/B,CAAC;AAEF,wBAAgB,iBAAiB,IAAI,MAAM,CAU1C;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYzD;AAED,eAAO,MAAM,kBAAkB,UAQ9B,CAAC"}

package/dist/knowledge/philosophy.js

@@ -0,0 +1,427 @@
+// =============================================================================
+// REACTIVE FRONTEND ARCHITECTURE — CORE PHILOSOPHY
+// =============================================================================
+// This is the heart of the MCP server. It contains the complete reactive
+// architecture philosophy that AI assistants should follow when building
+// frontend applications, regardless of the framework.
+// =============================================================================
+export const PHILOSOPHY_OVERVIEW = `
+# Reactive Frontend Architecture Philosophy
+
+## Core Principle
+Every frontend feature MUST be structured following **three clearly separated layers**:
+
+\`\`\`
+Component → Store → Service
+   (UI)    (State)  (Data Access)
+\`\`\`
+
+This is a **strict, non-negotiable pattern**. It applies to EVERY feature, in EVERY framework (Angular, React, Vue, Svelte, or any other). The technology changes, the philosophy does NOT.
+
+## Why This Pattern?
+
+1. **Predictability**: Data always flows in one direction. You always know where state lives and how it changes.
+2. **Testability**: Each layer can be tested in isolation. Components test rendering, stores test logic, services test data access.
+3. **Reusability**: Services can be shared across stores. Stores can be shared across components. Components are self-contained.
+4. **Scalability**: Adding features doesn't increase complexity because each feature follows the same pattern.
+5. **AI-Friendly**: When AI assistants follow this pattern consistently, the codebase remains coherent regardless of who (or what) writes the code.
+`;
+export const COMPONENT_LAYER = `
+# Component Layer (UI / Presentation)
+
+## Responsibility
+The component is **ONLY** responsible for:
+- Rendering UI based on state from the store
+- Capturing user interactions (clicks, input, navigation)
+- Dispatching actions/calls to the store
+- Presentational logic ONLY (formatting dates, toggling CSS classes)
+
+## Rules
+
+### MUST
+- Read all data from the store (via selectors, signals, observables, or reactive primitives)
+- Delegate ALL side effects to the store (loading data, submitting forms, etc.)
+- Be as "dumb" as possible — a template with holes filled by the store
+- Handle only UI concerns: show/hide, enable/disable, format display values
+
+### MUST NOT
+- Call HTTP/fetch/axios directly — NEVER
+- Contain business logic (validation rules, calculations, transformations)
+- Hold application state in local variables (only ephemeral UI state like "is dropdown open")
+- Know about the data access layer (services) — it only knows the store
+- Import or inject services directly
+
+## Ephemeral UI State (The Exception)
+Components CAN hold purely ephemeral UI state that has no business meaning:
+- \`isDropdownOpen\`
+- \`currentTabIndex\`
+- \`isModalVisible\`
+
+This state dies with the component and has no impact on application logic.
+
+## Mental Model
+> Think of the component as a **TV screen**: it displays what the store tells it, and it has a remote control (user interactions) that sends commands to the store. The TV never fetches channels itself.
+`;
+export const STORE_LAYER = `
+# Store Layer (State Management / Business Logic)
+
+## Responsibility
+The store is the **single source of truth** for a feature's state. It:
+- Holds the feature state (data, loading, error, filters, pagination, etc.)
+- Exposes reactive selectors/computed values for components to consume
+- Contains business logic (when to load, how to transform, validation orchestration)
+- Orchestrates service calls (calls the service, handles the response, updates state)
+
+## Rules
+
+### MUST
+- Be the ONLY place where feature state lives
+- Expose state as reactive primitives (signals, observables, reactive refs — depending on framework)
+- Handle loading/error/success states explicitly
+- Call services for any data access needs
+- Be the orchestrator: component asks → store decides → service fetches → store updates → component reacts
+
+### MUST NOT
+- Make HTTP calls directly — delegate to services
+- Know about the DOM or UI rendering
+- Depend on component lifecycle (it should be independent)
+- Import component code
+
+## State Shape Convention
+Every feature store should manage at minimum:
+\`\`\`typescript
+{
+  data: T | T[];           // The actual feature data
+  loading: boolean;        // Is data being fetched/submitted?
+  error: string | null;    // Error message if something failed
+  loaded: boolean;         // Has data been loaded at least once?
+}
+\`\`\`
+
+Additional state as needed:
+- \`filters\`, \`sorting\`, \`pagination\` for list features
+- \`selectedItem\` for detail views
+- \`formData\`, \`formErrors\` for form features
+
+## Mental Model
+> Think of the store as the **brain**: it knows the current state of everything, decides what to do when the component asks for something, and tells the service to go fetch or send data. It then updates its knowledge based on what comes back.
+`;
+export const SERVICE_LAYER = `
+# Service Layer (Data Access)
+
+## Responsibility
+The service is a **pure data access layer**. It:
+- Makes HTTP requests (GET, POST, PUT, DELETE)
+- Handles WebSocket connections
+- Accesses localStorage/sessionStorage
+- Interacts with any external data source
+
+## Rules
+
+### MUST
+- Be stateless — no internal state, no caching (that's the store's job)
+- Return data in a clean format (observables, promises, or the framework's preferred async primitive)
+- Handle request configuration (headers, base URL, interceptors)
+- Map API responses to domain models/interfaces if needed
+- Be reusable across different stores
+
+### MUST NOT
+- Hold state — NEVER
+- Contain business logic (no "if user is admin, do X")
+- Know about components or stores (it's a pure utility)
+- Handle loading/error state (that's the store's job)
+- Transform data for display purposes (that's the component's job)
+
+## Service Method Convention
+\`\`\`typescript
+// GOOD: Clean, simple, one job
+getUsers(): Observable<User[]> | Promise<User[]>
+getUserById(id: string): Observable<User> | Promise<User>
+createUser(data: CreateUserDto): Observable<User> | Promise<User>
+updateUser(id: string, data: UpdateUserDto): Observable<User> | Promise<User>
+deleteUser(id: string): Observable<void> | Promise<void>
+
+// BAD: Doing too much
+getUsersAndTransformForDisplay()  // ❌ Transformation is store/component job
+getUsersIfNotCached()             // ❌ Caching is the store's job
+getUsersAndSetLoading()           // ❌ Loading state is the store's job
+\`\`\`
+
+## Mental Model
+> Think of the service as a **messenger/courier**: it goes out, gets or delivers the package, and comes back. It doesn't open the package, doesn't decide what to do with it, and doesn't remember what it delivered yesterday.
+`;
+export const ANTI_PATTERNS = `
+# Anti-patterns — What NOT To Do
+
+## 1. HTTP in Components ❌
+\`\`\`typescript
+// ❌ WRONG: Component calling HTTP directly
+class UserListComponent {
+  users = [];
+  async ngOnInit() {
+    this.users = await fetch('/api/users').then(r => r.json());
+  }
+}
+
+// ✅ CORRECT: Component reads from store
+class UserListComponent {
+  users = this.userStore.users;
+  constructor(private userStore: UserStore) {
+    this.userStore.loadUsers();
+  }
+}
+\`\`\`
+
+## 2. Business Logic in Services ❌
+\`\`\`typescript
+// ❌ WRONG: Service deciding business rules
+class UserService {
+  async getVisibleUsers() {
+    const users = await this.http.get('/users');
+    return users.filter(u => u.role !== 'admin' && u.isActive);
+  }
+}
+
+// ✅ CORRECT: Service returns raw data, store filters
+class UserService {
+  getUsers() { return this.http.get('/users'); }
+}
+class UserStore {
+  visibleUsers = computed(() =>
+    this.users().filter(u => u.role !== 'admin' && u.isActive)
+  );
+}
+\`\`\`
+
+## 3. State in Services ❌
+\`\`\`typescript
+// ❌ WRONG: Service holding state
+class UserService {
+  private users: User[] = [];
+  private loading = false;
+
+  async loadUsers() {
+    this.loading = true;
+    this.users = await fetch('/api/users');
+    this.loading = false;
+  }
+}
+
+// ✅ CORRECT: State lives in the store
+class UserStore {
+  readonly users = signal<User[]>([]);
+  readonly loading = signal(false);
+
+  async loadUsers() {
+    this.loading.set(true);
+    const data = await this.userService.getUsers();
+    this.users.set(data);
+    this.loading.set(false);
+  }
+}
+\`\`\`
+
+## 4. Component Holding Business State ❌
+\`\`\`typescript
+// ❌ WRONG: Component managing complex state
+class UserListComponent {
+  users: User[] = [];
+  filteredUsers: User[] = [];
+  filters = { search: '', role: 'all' };
+  loading = false;
+  error = null;
+
+  applyFilters() { /* complex filtering */ }
+}
+
+// ✅ CORRECT: Store manages state, component just reads
+class UserListComponent {
+  users = this.store.filteredUsers;
+  loading = this.store.loading;
+  error = this.store.error;
+}
+\`\`\`
+
+## 5. Store Accessing DOM ❌
+\`\`\`typescript
+// ❌ WRONG: Store manipulating DOM
+class UserStore {
+  showSuccessMessage() {
+    document.getElementById('toast').style.display = 'block';
+  }
+}
+
+// ✅ CORRECT: Store updates state, component reacts
+class UserStore {
+  readonly notification = signal<string | null>(null);
+}
+// Component template reacts to notification signal
+\`\`\`
+
+## 6. Skipping the Store ❌
+\`\`\`typescript
+// ❌ WRONG: Component calling service directly
+class UserComponent {
+  constructor(private userService: UserService) {}
+  async save() {
+    await this.userService.createUser(this.formData);
+  }
+}
+
+// ✅ CORRECT: Component goes through store
+class UserComponent {
+  constructor(private userStore: UserStore) {}
+  save() {
+    this.userStore.createUser(this.formData);
+  }
+}
+\`\`\`
+`;
+export const FILE_STRUCTURE = `
+# File Structure Convention
+
+Every feature should follow this directory structure:
+
+\`\`\`
+src/
+├── features/
+│   └── users/                    # Feature folder
+│       ├── components/           # All components for this feature
+│       │   ├── user-list/
+│       │   │   ├── user-list.component.ts
+│       │   │   ├── user-list.component.html   # (if framework uses templates)
+│       │   │   └── user-list.component.css
+│       │   ├── user-detail/
+│       │   │   └── ...
+│       │   └── user-form/
+│       │       └── ...
+│       ├── store/                # Feature store
+│       │   ├── user.store.ts
+│       │   └── user.store.spec.ts
+│       ├── services/             # Data access services
+│       │   ├── user.service.ts
+│       │   └── user.service.spec.ts
+│       ├── models/               # TypeScript interfaces & types
+│       │   └── user.model.ts
+│       └── index.ts              # Public API barrel file
+├── shared/                       # Cross-feature shared code
+│   ├── components/               # Reusable UI components
+│   ├── services/                 # Shared services (auth, http interceptor)
+│   ├── stores/                   # Shared stores (auth, ui, notifications)
+│   └── models/                   # Shared interfaces & types
+└── core/                         # App-wide singletons
+    ├── auth/
+    ├── layout/
+    └── config/
+\`\`\`
+
+## Naming Conventions
+- Feature folders: **kebab-case** (e.g., \`user-management\`)
+- Store files: \`<feature>.store.ts\`
+- Service files: \`<feature>.service.ts\`
+- Model files: \`<feature>.model.ts\`
+- Component files: \`<component-name>.component.ts\`
+- Test files: \`<file>.spec.ts\` or \`<file>.test.ts\`
+
+## Barrel Files (index.ts)
+Every feature folder MUST have an \`index.ts\` that exports the public API:
+\`\`\`typescript
+// features/users/index.ts
+export { UserListComponent } from './components/user-list/user-list.component';
+export { UserStore } from './store/user.store';
+export { UserService } from './services/user.service';
+export type { User, CreateUserDto } from './models/user.model';
+\`\`\`
+`;
+export const IMPLEMENTATION_FLOW = `
+# Implementation Flow — How to Build a Feature
+
+When implementing a new feature, ALWAYS follow this order:
+
+## Step 1: Define the Model
+Create the TypeScript interfaces/types that represent the data:
+\`\`\`typescript
+// models/user.model.ts
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+  role: 'admin' | 'user';
+  isActive: boolean;
+}
+
+export interface CreateUserDto {
+  name: string;
+  email: string;
+  role: 'admin' | 'user';
+}
+\`\`\`
+
+## Step 2: Build the Service
+Create the data access layer (HTTP calls):
+\`\`\`typescript
+// services/user.service.ts
+// Returns promises or observables, nothing more
+\`\`\`
+
+## Step 3: Build the Store
+Create the state management layer:
+\`\`\`typescript
+// store/user.store.ts
+// Holds state, calls service, exposes reactive selectors
+\`\`\`
+
+## Step 4: Build the Component
+Create the UI that reads from the store:
+\`\`\`typescript
+// components/user-list/user-list.component.ts
+// Reads from store, dispatches to store, renders UI
+\`\`\`
+
+## Step 5: Write Tests
+- Service tests: Mock HTTP, verify requests
+- Store tests: Mock service, verify state transitions
+- Component tests: Mock store, verify rendering & interactions
+
+## Why This Order?
+- **Model first**: defines the contract between all layers
+- **Service second**: it has no dependencies, easiest to build and test
+- **Store third**: depends only on service, contains the logic
+- **Component last**: depends on store, is purely visual
+- **Tests alongside or after**: ensures each layer works correctly
+
+This is a **bottom-up** approach that ensures you never build a layer without its dependency being ready.
+`;
+export function getFullPhilosophy() {
+    return [
+        PHILOSOPHY_OVERVIEW,
+        COMPONENT_LAYER,
+        STORE_LAYER,
+        SERVICE_LAYER,
+        ANTI_PATTERNS,
+        FILE_STRUCTURE,
+        IMPLEMENTATION_FLOW,
+    ].join('\n\n---\n\n');
+}
+export function getSection(section) {
+    const sections = {
+        overview: PHILOSOPHY_OVERVIEW,
+        component: COMPONENT_LAYER,
+        store: STORE_LAYER,
+        service: SERVICE_LAYER,
+        'anti-patterns': ANTI_PATTERNS,
+        'file-structure': FILE_STRUCTURE,
+        'implementation-flow': IMPLEMENTATION_FLOW,
+    };
+    return sections[section] ?? null;
+}
+export const AVAILABLE_SECTIONS = [
+    'overview',
+    'component',
+    'store',
+    'service',
+    'anti-patterns',
+    'file-structure',
+    'implementation-flow',
+];
+//# sourceMappingURL=philosophy.js.map

package/dist/knowledge/philosophy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"philosophy.js","sourceRoot":"","sources":["../../src/knowledge/philosophy.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,mDAAmD;AACnD,gFAAgF;AAChF,yEAAyE;AACzE,yEAAyE;AACzE,sDAAsD;AACtD,gFAAgF;AAEhF,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;CAoBlC,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmC9B,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C1B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C5B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8H5B,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuD7B,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DlC,CAAC;AAEF,MAAM,UAAU,iBAAiB;IAC7B,OAAO;QACH,mBAAmB;QACnB,eAAe;QACf,WAAW;QACX,aAAa;QACb,aAAa;QACb,cAAc;QACd,mBAAmB;KACtB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,OAAe;IACtC,MAAM,QAAQ,GAA2B;QACrC,QAAQ,EAAE,mBAAmB;QAC7B,SAAS,EAAE,eAAe;QAC1B,KAAK,EAAE,WAAW;QAClB,OAAO,EAAE,aAAa;QACtB,eAAe,EAAE,aAAa;QAC9B,gBAAgB,EAAE,cAAc;QAChC,qBAAqB,EAAE,mBAAmB;KAC7C,CAAC;IAEF,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;AACrC,CAAC;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAC9B,UAAU;IACV,WAAW;IACX,OAAO;IACP,SAAS;IACT,eAAe;IACf,gBAAgB;IAChB,qBAAqB;CACxB,CAAC"}

package/dist/knowledge/stack-guides.d.ts

@@ -0,0 +1,18 @@
+export type Stack = 'angular' | 'react' | 'vue' | 'svelte' | 'unknown';
+export interface StackGuide {
+    stack: Stack;
+    displayName: string;
+    stateLibrary: string;
+    httpPattern: string;
+    reactivityModel: string;
+    guide: string;
+}
+export declare function getStackGuide(stack: Stack): StackGuide;
+export interface DetectedStackInfo {
+    stack: Stack;
+    stateLib?: 'redux' | 'zustand' | 'tanstack-query' | 'ngrx' | 'pinia' | 'svelte-stores';
+}
+export declare function detectStackFromDependencies(deps: Record<string, string>): Stack;
+export declare function detectStateLibrary(deps: Record<string, string>): string | null;
+export declare function getAllStackGuides(): string;
+//# sourceMappingURL=stack-guides.d.ts.map

package/dist/knowledge/stack-guides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-guides.d.ts","sourceRoot":"","sources":["../../src/knowledge/stack-guides.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEvE,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf;AAqyBD,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAEtD;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,gBAAgB,GAAG,MAAM,GAAG,OAAO,GAAG,eAAe,CAAC;CACxF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAM/E;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAU9E;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAK1C"}