@gherk/reactive-architecture 1.3.0 → 1.3.2

package/dist/index.js

@@ -22,6 +22,8 @@ import { registerFolderStructureTool } from './tools/folder-structure.js';
 import { registerBackendGuideTool } from './tools/backend-guide.js';
 import { registerBackendFolderStructureTool } from './tools/backend-folder-structure.js';
 import { registerAuditProjectTool } from './tools/audit-project.js';
+import { registerScanElementsTool } from './tools/scan-elements.js';
+import { registerCreateElementTool } from './tools/create-element.js';
 // Resources
 import { registerPhilosophyResource } from './resources/philosophy-resource.js';
 // Prompts
@@ -42,6 +44,8 @@ registerFolderStructureTool(server);
 registerBackendGuideTool(server);
 registerBackendFolderStructureTool(server);
 registerAuditProjectTool(server);
+registerScanElementsTool(server);
+registerCreateElementTool(server);
 // Register resources
 registerPhilosophyResource(server);
 // Register prompts
@@ -50,7 +54,7 @@ registerPlanFeaturePrompt(server);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('🚀 Reactive Frontend MCP Server running on stdio');
+    // console.error('🚀 Reactive Frontend MCP Server running on stdio');
 }
 main().catch((error) => {
     console.error('Fatal error:', error);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,gFAAgF;AAChF,mCAAmC;AACnC,gFAAgF;AAChF,qEAAqE;AACrE,qDAAqD;AACrD,mDAAmD;AACnD,EAAE;AACF,wEAAwE;AACxE,kCAAkC;AAClC,gFAAgF;AAEhF,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAEjF,QAAQ;AACR,OAAO,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,kCAAkC,EAAE,MAAM,qCAAqC,CAAC;AACzF,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,YAAY;AACZ,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAEhF,UAAU;AACV,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,wBAAwB;AACxB,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;IACzB,IAAI,EAAE,uBAAuB;IAC7B,OAAO,EAAE,OAAO;CACnB,CAAC,CAAC;AAEH,qBAAqB;AACrB,6BAA6B,CAAC,MAAM,CAAC,CAAC;AACtC,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAC7B,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAC7B,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAC7B,0BAA0B,CAAC,MAAM,CAAC,CAAC;AACnC,sBAAsB,CAAC,MAAM,CAAC,CAAC;AAC/B,2BAA2B,CAAC,MAAM,CAAC,CAAC;AACpC,wBAAwB,CAAC,MAAM,CAAC,CAAC;AACjC,kCAAkC,CAAC,MAAM,CAAC,CAAC;AAC3C,wBAAwB,CAAC,MAAM,CAAC,CAAC;AAEjC,qBAAqB;AACrB,0BAA0B,CAAC,MAAM,CAAC,CAAC;AAEnC,mBAAmB;AACnB,yBAAyB,CAAC,MAAM,CAAC,CAAC;AAElC,8BAA8B;AAC9B,KAAK,UAAU,IAAI;IACf,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,OAAO,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAC;AACtE,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;IACrC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,gFAAgF;AAChF,mCAAmC;AACnC,gFAAgF;AAChF,qEAAqE;AACrE,qDAAqD;AACrD,mDAAmD;AACnD,EAAE;AACF,wEAAwE;AACxE,kCAAkC;AAClC,gFAAgF;AAEhF,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAEjF,QAAQ;AACR,OAAO,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,kCAAkC,EAAE,MAAM,qCAAqC,CAAC;AACzF,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,YAAY;AACZ,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAEhF,UAAU;AACV,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,wBAAwB;AACxB,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;IACzB,IAAI,EAAE,uBAAuB;IAC7B,OAAO,EAAE,OAAO;CACnB,CAAC,CAAC;AAEH,qBAAqB;AACrB,6BAA6B,CAAC,MAAM,CAAC,CAAC;AACtC,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAC7B,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAC7B,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAC7B,0BAA0B,CAAC,MAAM,CAAC,CAAC;AACnC,sBAAsB,CAAC,MAAM,CAAC,CAAC;AAC/B,2BAA2B,CAAC,MAAM,CAAC,CAAC;AACpC,wBAAwB,CAAC,MAAM,CAAC,CAAC;AACjC,kCAAkC,CAAC,MAAM,CAAC,CAAC;AAC3C,wBAAwB,CAAC,MAAM,CAAC,CAAC;AACjC,wBAAwB,CAAC,MAAM,CAAC,CAAC;AACjC,yBAAyB,CAAC,MAAM,CAAC,CAAC;AAElC,qBAAqB;AACrB,0BAA0B,CAAC,MAAM,CAAC,CAAC;AAEnC,mBAAmB;AACnB,yBAAyB,CAAC,MAAM,CAAC,CAAC;AAElC,8BAA8B;AAC9B,KAAK,UAAU,IAAI;IACf,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,qEAAqE;AACzE,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;IACrC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC,CAAC,CAAC"}

package/dist/knowledge/philosophy.d.ts

@@ -1,8 +1,8 @@
 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 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** \u2014 CRITICAL VIOLATION\n- Call **service.method()** \u2014 ALWAYS go through **store.method()**\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 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 (CRITICAL VIOLATION) \u274C\n```typescript\n// \u274C WRONG: Component calling service directly.\n// NEVER inject a Service into a Component.\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;

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

@@ -1 +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"}
+{"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,qlDAoC3B,CAAC;AAEF,eAAO,MAAM,WAAW,2zDA2CvB,CAAC;AAEF,eAAO,MAAM,aAAa,gyDA2CzB,CAAC;AAEF,eAAO,MAAM,aAAa,4hGA+HzB,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

@@ -48,8 +48,9 @@ The component is **ONLY** responsible for:
 - 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
+- **Know about the data access layer (services)** — it only knows the store
+- **Import or inject services directly** — CRITICAL VIOLATION
+- Call **service.method()** — ALWAYS go through **store.method()**
 
 ## Ephemeral UI State (The Exception)
 Components CAN hold purely ephemeral UI state that has no business meaning:
@@ -258,9 +259,10 @@ class UserStore {
 // Component template reacts to notification signal
 \`\`\`
 
-## 6. Skipping the Store ❌
+## 6. Skipping the Store (CRITICAL VIOLATION) ❌
 \`\`\`typescript
-// ❌ WRONG: Component calling service directly
+// ❌ WRONG: Component calling service directly.
+// NEVER inject a Service into a Component.
 class UserComponent {
   constructor(private userService: UserService) {}
   async save() {

package/dist/knowledge/philosophy.js.map

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC9B,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C1B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C5B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+H5B,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuD7B,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DlC,CAAC;AAEF,MAAM,UAAU,iBAAiB;IAC/B,OAAO;QACL,mBAAmB;QACnB,eAAe;QACf,WAAW;QACX,aAAa;QACb,aAAa;QACb,cAAc;QACd,mBAAmB;KACpB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,OAAe;IACxC,MAAM,QAAQ,GAA2B;QACvC,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;KAC3C,CAAC;IAEF,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;AACnC,CAAC;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,UAAU;IACV,WAAW;IACX,OAAO;IACP,SAAS;IACT,eAAe;IACf,gBAAgB;IAChB,qBAAqB;CACtB,CAAC"}

package/dist/tools/create-element.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerCreateElementTool(server: McpServer): void;
+//# sourceMappingURL=create-element.d.ts.map

package/dist/tools/create-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-element.d.ts","sourceRoot":"","sources":["../../src/tools/create-element.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmBpE,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,QAuH1D"}

package/dist/tools/create-element.js

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+function toPascalCase(str) {
+    return str
+        .split(/[-_\s]+/)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join('');
+}
+export function registerCreateElementTool(server) {
+    server.tool('create_element', {
+        projectPath: z.string().describe('Absolute path to the project root'),
+        name: z.string().describe('Name of the element (e.g. "user-card", "custom-input")'),
+        type: z.enum(['atomic', 'form-control']).default('atomic').describe('Type of element: atomic (display/interactive) or form-control (implements ControlValueAccessor)'),
+        inputs: z.array(z.string()).optional().describe('List of input names (e.g. ["title", "isActive"])'),
+    }, async ({ projectPath, name, type, inputs = [] }) => {
+        const kebab = toKebabCase(name);
+        const pascal = toPascalCase(name);
+        const elementsDir = path.join(projectPath, 'src/app/elements', kebab);
+        if (fs.existsSync(elementsDir)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: Element '${kebab}' already exists at ${elementsDir}`
+                    }]
+            };
+        }
+        fs.mkdirSync(elementsDir, { recursive: true });
+        let tsContent = '';
+        const cssContent = `:host {\n  display: block;\n}\n`;
+        let htmlContent = `<p>${kebab} works!</p>`;
+        const inputSignals = inputs.map(i => `  ${i} = input<string>('');`).join('\n');
+        if (type === 'form-control') {
+            tsContent = `import { Component, forwardRef, signal } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
+
+@Component({
+  selector: 'ghk-${kebab}',
+  standalone: true,
+  imports: [CommonModule],
+  templateUrl: './${kebab}.component.html',
+  styleUrl: './${kebab}.component.css',
+  providers: [{
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => ${pascal}Component),
+    multi: true
+  }]
+})
+export class ${pascal}Component implements ControlValueAccessor {
+${inputSignals}
+
+  value = signal<string>('');
+  disabled = signal<boolean>(false);
+
+  onChange: (value: string) => void = () => {};
+  onTouched: () => void = () => {};
+
+  writeValue(obj: any): void {
+    this.value.set(obj || '');
+  }
+
+  registerOnChange(fn: any): void {
+    this.onChange = fn;
+  }
+
+  registerOnTouched(fn: any): void {
+    this.onTouched = fn;
+  }
+
+  setDisabledState(isDisabled: boolean): void {
+    this.disabled.set(isDisabled);
+  }
+
+  updateValue(newValue: string) {
+    this.value.set(newValue);
+    this.onChange(newValue);
+    this.onTouched();
+  }
+}
+`;
+            htmlContent = `<input 
+  [value]="value()" 
+  (input)="updateValue($any($event.target).value)" 
+  [disabled]="disabled()"
+  class="ghk-input"
+/>`;
+        }
+        else {
+            // Atomic Component (Signal-based)
+            tsContent = `import { Component, input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+@Component({
+  selector: 'ghk-${kebab}',
+  standalone: true,
+  imports: [CommonModule],
+  templateUrl: './${kebab}.component.html',
+  styleUrl: './${kebab}.component.css'
+})
+export class ${pascal}Component {
+${inputSignals}
+}
+`;
+            if (inputs.length > 0) {
+                htmlContent = `<div>\n${inputs.map(i => `  <p>{{ ${i}() }}</p>`).join('\n')}\n</div>`;
+            }
+        }
+        fs.writeFileSync(path.join(elementsDir, `${kebab}.component.ts`), tsContent);
+        fs.writeFileSync(path.join(elementsDir, `${kebab}.component.html`), htmlContent);
+        fs.writeFileSync(path.join(elementsDir, `${kebab}.component.css`), cssContent);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Created atomic element '${kebab}' in src/app/elements/${kebab}\n- Component: ${pascal}Component\n- Check it out and add styles!`
+                }]
+        };
+    });
+}
+//# sourceMappingURL=create-element.js.map

package/dist/tools/create-element.js.map

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

package/dist/tools/scan-elements.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerScanElementsTool(server: McpServer): void;
+//# sourceMappingURL=scan-elements.d.ts.map

package/dist/tools/scan-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-elements.d.ts","sourceRoot":"","sources":["../../src/tools/scan-elements.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKpE,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,QA6FzD"}

package/dist/tools/scan-elements.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+export function registerScanElementsTool(server) {
+    server.tool('scan_elements', {
+        projectPath: z.string().describe('Absolute path to the project root'),
+        elementsPath: z.string().optional().describe('Relative path to elements folder (default: src/app/elements)'),
+    }, async ({ projectPath, elementsPath = 'src/app/elements' }) => {
+        const fullElementsPath = path.join(projectPath, elementsPath);
+        if (!fs.existsSync(fullElementsPath)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No elements folder found at ${fullElementsPath}. Recommend creating atomic components in 'src/app/elements'.`
+                    }]
+            };
+        }
+        const elements = [];
+        function scanDir(dir) {
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                const fullPath = path.join(dir, file);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    scanDir(fullPath);
+                }
+                else if (file.endsWith('.component.ts')) {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    // Extract selector
+                    const selectorMatch = content.match(/selector:\s*['"`]([^'"`]+)['"`]/);
+                    const selector = selectorMatch ? selectorMatch[1] : 'unknown-selector';
+                    // Extract inputs (Signal inputs)
+                    const inputs = [];
+                    const lines = content.split('\n');
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if ((trimmed.includes('input<') || trimmed.includes('input.required<')) && !trimmed.startsWith('//')) {
+                            inputs.push(trimmed);
+                        }
+                    }
+                    // Extract standalone flag
+                    const isStandalone = content.includes('standalone: true');
+                    // Component Name (Class name)
+                    const classMatch = content.match(/export\s+class\s+(\w+)/);
+                    const className = classMatch ? classMatch[1] : 'UnknownComponent';
+                    elements.push(`
+- **<${selector}>** (${className})
+  Location: ${path.relative(projectPath, fullPath)}
+  Standalone: ${isStandalone}
+  Inputs:
+${inputs.map(i => `    * ${i}`).join('\n')}
+`);
+                }
+            }
+        }
+        try {
+            scanDir(fullElementsPath);
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error scanning elements: ${err.message}`
+                    }]
+            };
+        }
+        if (elements.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No components found in ${fullElementsPath}.`
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `FOUND ${elements.length} ATOMIC ELEMENTS (REUSE THESE PREFERABLY):\n${elements.join('\n')}`
+                }]
+        };
+    });
+}
+//# sourceMappingURL=scan-elements.js.map

package/dist/tools/scan-elements.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gherk/reactive-architecture",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "MCP server that teaches AI assistants the reactive architecture philosophy: Component → Store → Service + Controller → Service → Repository",
   "type": "module",
   "main": "dist/index.js",