magector 2.2.6 → 2.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 **Technology-aware MCP server for Magento 2 and Adobe Commerce with intelligent indexing and search.**
 
-Magector is a Model Context Protocol (MCP) server that deeply understands Magento 2 and Adobe Commerce. It builds a semantic vector index of your entire codebase — 18,000+ files across hundreds of modules — and exposes 28 tools that let AI assistants search, navigate, and understand the code with domain-specific intelligence. Instead of grepping for keywords, your AI asks *"how are checkout totals calculated?"* and gets ranked, relevant results in under 50ms, enriched with Magento pattern detection (plugins, observers, controllers, DI preferences, layout XML, and 20+ more).
+Magector is a Model Context Protocol (MCP) server that deeply understands Magento 2 and Adobe Commerce. It builds a semantic vector index of your entire codebase — 18,000+ files across hundreds of modules — and exposes 34 tools that let AI assistants search, navigate, and understand the code with domain-specific intelligence. Instead of grepping for keywords, your AI asks *"how are checkout totals calculated?"* and gets ranked, relevant results in under 50ms, enriched with Magento pattern detection (plugins, observers, controllers, DI preferences, layout XML, and 20+ more).
 
 [![Rust](https://img.shields.io/badge/rust-1.75+-orange.svg)](https://www.rust-lang.org)
 [![Node.js](https://img.shields.io/badge/node-18+-green.svg)](https://nodejs.org)
@@ -58,7 +58,7 @@ The result: your AI assistant calls one MCP tool and gets ranked, pattern-enrich
 - **Complexity analysis** -- cyclomatic complexity, function count, and hotspot detection across modules
 - **Fast** -- 10-45ms queries via persistent serve process, batched ONNX embedding with adaptive thread scaling
 - **LLM description enrichment** -- generate natural-language descriptions of di.xml files using Claude, stored in SQLite, and prepend them to embedding text so descriptions influence vector search ranking (not just post-retrieval display)
-- **MCP server** -- 28 tools integrating with Claude Code, Cursor, and any MCP-compatible AI tool
+- **MCP server** -- 34 tools integrating with Claude Code, Cursor, and any MCP-compatible AI tool
 - **Clean architecture** -- Rust core handles all indexing/search, Node.js MCP server delegates to it
 
 ---
@@ -70,7 +70,7 @@ flowchart LR
   subgraph node ["Node.js Layer"]
     direction TB
     G["CLI<br/>init · index · search · describe"]
-    E["MCP Server<br/>28 tools · LRU cache"]
+    E["MCP Server<br/>34 tools · LRU cache"]
     F["Persistent Serve Process"]
     G --> F
     E --> F
@@ -369,7 +369,7 @@ npx magector index --force
 
 ## MCP Server Tools
 
-The MCP server exposes 28 tools for AI-assisted Magento 2 and Adobe Commerce development. All search tools return **structured JSON** with file paths, class names, methods, role badges, and content snippets -- enabling AI clients to parse results programmatically and minimize file-read round-trips.
+The MCP server exposes 34 tools for AI-assisted Magento 2 and Adobe Commerce development. All search tools return **structured JSON** with file paths, class names, methods, role badges, and content snippets -- enabling AI clients to parse results programmatically and minimize file-read round-trips.
 
 ### Output Format
 
@@ -432,7 +432,10 @@ All search tools return structured JSON:
 | `magento_trace_flow` | Trace execution flow from an entry point (route, API, GraphQL, event, cron) -- maps controller → plugins → observers → templates in one call |
 | `magento_trace_dependency` | Trace DI graph for a class/interface -- preferences, plugins, virtualTypes, argument overrides (parses all di.xml, no index needed) |
 | `magento_find_event_flow` | Trace complete event chain: dispatchers → observers → handler PHP classes (parses events.xml + vector search) |
+| `magento_find_event_dispatchers` | Find all PHP locations where a specific event is dispatched -- exact grep matching with method context and surrounding code **(v2.3)** |
 | `magento_find_layout` | Find layout XML files by handle or content -- lists blocks, containers, and referenceBlock declarations |
+| `magento_trace_data_flow` | Trace how a data attribute flows: find all setters (magic setter, setData, addData) and getters (magic getter, getData) across PHP and XML **(v2.3)** |
+| `magento_trace_call_chain` | Trace internal method call chain: follows `$this->method()`, `$this->dep->method()`, and `dispatch()` calls to build an execution tree **(v2.2)** |
 
 Auto-detects entry type from pattern (`/V1/...` → API, `snake_case` → event, `camelCase` → GraphQL, `path/segments` → route), or override with `entryType`. Use `depth: "shallow"` (entry + config + plugins) or `depth: "deep"` (adds observers, layout, templates, DI preferences).
 
@@ -442,6 +445,9 @@ Auto-detects entry type from pattern (`/V1/...` → API, `snake_case` → event,
 |------|-------------|
 | `magento_impact_analysis` | Analyze impact of changing a class -- finds use statements, DI references, direct instantiations, and type hints across the codebase |
 | `magento_find_test` | Find PHPUnit tests for a given class/method -- searches Test/ directories for coverage, mocks, and assertions |
+| `magento_find_implementors` | Find all classes implementing a given PHP interface -- scans `implements` keywords and di.xml `<preference>` declarations **(v2.2)** |
+| `magento_find_callers` | Find all call sites of a method across PHP and XML files -- `->method()` and `::method()` calls **(v2.2)** |
+| `magento_find_di_wiring` | Complete DI picture for a class: preferences, plugins, constructor args, virtual types, and argument overrides from di.xml **(v2.2)** |
 
 ### Diagnostics
 
@@ -470,9 +476,22 @@ Auto-detects entry type from pattern (`/V1/...` → API, `snake_case` → event,
 
 - **Hybrid BM25+vector search** -- combines text frequency scoring with semantic vector similarity for better exact class name matches
 - **Query expansion** -- automatically expands queries with Magento domain synonyms (plugin → interceptor, checkout → cart/quote/totals, etc.)
-- **Module filtering** -- `moduleFilter` parameter on `magento_search` to limit results by vendor/module pattern (supports wildcards, e.g., `"Vendor_*"`)
+- **Module filtering** -- `moduleFilter` parameter on `magento_search` to limit results by vendor/module pattern. Accepts a single string or array of strings. Supports wildcards, e.g., `"Vendor_*"` or `["Acme_PaymentGateway", "Acme_FreeShipping"]`
 - **Non-blocking reindex** -- old index stays usable during background rebuild; new index is built to a temp path and swapped in atomically on completion
 
+### Deep Code Analysis (v2.2)
+
+- **`magento_find_implementors`** -- find all classes implementing a PHP interface (PHP `implements` + di.xml `<preference>`)
+- **`magento_find_callers`** -- find all call sites of a method across PHP and XML files
+- **`magento_find_di_wiring`** -- complete DI picture: preferences, plugins, constructor args, virtual types, argument overrides
+- **`magento_trace_call_chain`** -- trace internal method execution chain: `$this->method()`, `$this->dep->method()`, and `dispatch()` calls with event→observer resolution
+
+### Data Flow & Event Tracing (v2.3)
+
+- **`magento_trace_data_flow`** -- trace all setters and getters for a data attribute (magic methods, setData/getData, addData, constants, XML references). Answers "who writes/reads `custom_discounted_price_incl_tax` on `Quote\Address`?"
+- **`magento_find_event_dispatchers`** -- grep-based exact search for all PHP locations dispatching a specific event, with method context and surrounding code. Complements `magento_find_event_flow` with higher precision.
+- **`magento_find_plugin` area context** -- enriched output shows DI area (frontend/adminhtml/global/graphql) and explicit di.xml plugin registrations when `targetClass` is provided
+
 ### Tool Cross-References
 
 Each tool description includes "See also" hints to help AI clients chain tools effectively:
@@ -549,6 +568,12 @@ magento_trace_flow({ entryPoint: "checkout/cart/add", depth: "deep" })
 magento_trace_flow({ entryPoint: "/V1/products" })
 magento_trace_flow({ entryPoint: "placeOrder", entryType: "graphql" })
 magento_trace_flow({ entryPoint: "sales_order_place_after" })
+magento_trace_data_flow({ attributeKey: "custom_discounted_price_incl_tax", modelClass: "Quote\\Address" })
+magento_find_event_dispatchers({ eventName: "custom_discount_rule_validation_before" })
+magento_find_implementors({ interfaceName: "ProductRepositoryInterface" })
+magento_find_callers({ methodName: "collectTotals", className: "TotalsCollector" })
+magento_find_di_wiring({ className: "CartManagementInterface" })
+magento_trace_call_chain({ className: "Magento\\Quote\\Model\\QuoteManagement", methodName: "submit" })
 ```
 
 ---
@@ -629,7 +654,7 @@ cd rust-core && cargo run --release -- validate -m ./magento2 --skip-index
 magector/
 ├── src/                          # Node.js source
 │   ├── cli.js                    # CLI entry point (npx magector <command>)
-│   ├── mcp-server.js             # MCP server (20 tools, structured JSON output)
+│   ├── mcp-server.js             # MCP server (34 tools, structured JSON output)
 │   ├── binary.js                 # Platform binary resolver
 │   ├── model.js                  # ONNX model resolver/downloader
 │   ├── init.js                   # Full init command (index + IDE config)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magector",
-  "version": "2.2.6",
+  "version": "2.3.1",
   "description": "Semantic code search for Magento 2 — index, search, MCP server",
   "type": "module",
   "main": "src/mcp-server.js",
@@ -23,13 +23,7 @@
     "test": "node tests/unit.test.js && node tests/mcp-server.test.js",
     "test:unit": "node tests/unit.test.js",
     "test:integration": "node tests/mcp-server.test.js",
-    "test:no-index": "node tests/mcp-server.test.js --no-index",
-    "test:accuracy": "node tests/mcp-accuracy.test.js",
-    "test:accuracy:verbose": "node tests/mcp-accuracy.test.js --verbose",
-    "test:sona-eval": "node tests/mcp-sona-eval.test.js",
-    "test:sona-eval:verbose": "node tests/mcp-sona-eval.test.js --verbose",
-    "test:describe-eval": "node tests/describe-benefit-eval.test.js",
-    "test:describe-eval:verbose": "node tests/describe-benefit-eval.test.js --verbose"
+    "test:no-index": "node tests/mcp-server.test.js --no-index"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
@@ -39,10 +33,10 @@
     "ruvector": "^0.1.96"
   },
   "optionalDependencies": {
-    "@magector/cli-darwin-arm64": "2.2.6",
-    "@magector/cli-linux-x64": "2.2.6",
-    "@magector/cli-linux-arm64": "2.2.6",
-    "@magector/cli-win32-x64": "2.2.6"
+    "@magector/cli-darwin-arm64": "2.3.1",
+    "@magector/cli-linux-x64": "2.3.1",
+    "@magector/cli-linux-arm64": "2.3.1",
+    "@magector/cli-win32-x64": "2.3.1"
   },
   "keywords": [
     "magento",

package/src/mcp-server.js

@@ -2362,6 +2362,244 @@ async function findDiWiring(className) {
   return result;
 }
 
+// ─── Trace Data Flow ───────────────────────────────────────────
+// Find all setters and getters for a data attribute across the codebase
+
+async function traceDataFlow(attributeKey, modelClass) {
+  const root = config.magentoRoot;
+
+  // Convert snake_case to PascalCase for magic method names
+  const pascal = attributeKey.split('_').map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+  const setterMethod = `set${pascal}`;
+  const getterMethod = `get${pascal}`;
+
+  const result = {
+    attributeKey,
+    setterMethod,
+    getterMethod,
+    setters: [],
+    getters: [],
+    xmlReferences: []
+  };
+
+  // 1. Search PHP files for setters/getters
+  const phpFiles = await glob('**/*.php', {
+    cwd: root, absolute: true, nodir: true,
+    ignore: ['**/test/**', '**/tests/**', '**/Test/**', '**/Tests/**']
+  });
+
+  const setterRegex = new RegExp(
+    `(?:->|::)${setterMethod}\\s*\\(|` +
+    `setData\\s*\\(\\s*['"]${attributeKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`
+  );
+  const getterRegex = new RegExp(
+    `(?:->|::)${getterMethod}\\s*\\(|` +
+    `getData\\s*\\(\\s*['"]${attributeKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`
+  );
+  // Also match addData calls that could set this attribute
+  const addDataRegex = new RegExp(
+    `addData\\s*\\(.*${attributeKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`
+  );
+  // Match constant definitions for this key
+  const constRegex = new RegExp(
+    `(?:const\\s+\\w+\\s*=\\s*['"]${attributeKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"])`
+  );
+
+  const shortModel = modelClass ? modelClass.split('\\').pop() : null;
+
+  for (const phpFile of phpFiles) {
+    let content;
+    try { content = readFileSync(phpFile, 'utf-8'); } catch { continue; }
+
+    // Quick pre-check
+    if (!content.includes(setterMethod) && !content.includes(getterMethod) &&
+        !content.includes(attributeKey)) continue;
+
+    // If modelClass specified, prioritize files that reference it
+    const refsModel = !shortModel || content.includes(shortModel);
+
+    const relativePath = phpFile.replace(root + '/', '');
+    const classMatch = content.match(/(?:class|abstract\s+class|trait)\s+(\w+)/);
+    const nsMatch = content.match(/namespace\s+([\w\\]+)/);
+    const className = classMatch ? classMatch[1] : path.basename(phpFile, '.php');
+    const fqcn = nsMatch ? `${nsMatch[1]}\\${className}` : className;
+    const lines = content.split('\n');
+
+    // Determine area from path
+    const area = relativePath.includes('/frontend/') ? 'frontend'
+      : relativePath.includes('/adminhtml/') ? 'adminhtml'
+      : relativePath.includes('/graphql/') ? 'graphql' : 'global';
+
+    // Find setter lines
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (setterRegex.test(line) || (addDataRegex.test(line) && line.includes(attributeKey))) {
+        // Find enclosing method
+        let methodName = null;
+        for (let j = i; j >= Math.max(0, i - 30); j--) {
+          const mMatch = lines[j].match(/(?:public|protected|private|static)\s+function\s+(\w+)/);
+          if (mMatch) { methodName = mMatch[1]; break; }
+        }
+        result.setters.push({
+          path: relativePath,
+          class: fqcn,
+          method: methodName,
+          line: i + 1,
+          snippet: line.trim().slice(0, 200),
+          referencesModel: refsModel,
+          area
+        });
+        break; // one entry per file for setters
+      }
+    }
+
+    // Find getter lines
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (getterRegex.test(line)) {
+        let methodName = null;
+        for (let j = i; j >= Math.max(0, i - 30); j--) {
+          const mMatch = lines[j].match(/(?:public|protected|private|static)\s+function\s+(\w+)/);
+          if (mMatch) { methodName = mMatch[1]; break; }
+        }
+        result.getters.push({
+          path: relativePath,
+          class: fqcn,
+          method: methodName,
+          line: i + 1,
+          snippet: line.trim().slice(0, 200),
+          referencesModel: refsModel,
+          area
+        });
+        break; // one entry per file for getters
+      }
+    }
+
+    // Find constant definitions
+    if (constRegex.test(content)) {
+      const constLine = lines.findIndex(l => constRegex.test(l));
+      if (constLine >= 0) {
+        result.setters.push({
+          path: relativePath,
+          class: fqcn,
+          method: null,
+          line: constLine + 1,
+          snippet: lines[constLine].trim().slice(0, 200),
+          type: 'constant',
+          area
+        });
+      }
+    }
+  }
+
+  // 2. Search XML files (sales.xml, extension_attributes.xml) for attribute references
+  const xmlFiles = await glob('**/etc/**/*.xml', { cwd: root, absolute: true, nodir: true });
+  const escapedKey = attributeKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const xmlRegex = new RegExp(escapedKey);
+
+  for (const xmlFile of xmlFiles) {
+    let content;
+    try { content = readFileSync(xmlFile, 'utf-8'); } catch { continue; }
+    if (!xmlRegex.test(content)) continue;
+
+    const relativePath = xmlFile.replace(root + '/', '');
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (xmlRegex.test(lines[i])) {
+        result.xmlReferences.push({
+          path: relativePath,
+          line: i + 1,
+          snippet: lines[i].trim().slice(0, 200)
+        });
+        break;
+      }
+    }
+  }
+
+  // Sort: files referencing the model get priority
+  if (shortModel) {
+    result.setters.sort((a, b) => (b.referencesModel ? 1 : 0) - (a.referencesModel ? 1 : 0));
+    result.getters.sort((a, b) => (b.referencesModel ? 1 : 0) - (a.referencesModel ? 1 : 0));
+  }
+
+  return result;
+}
+
+// ─── Find Event Dispatchers ────────────────────────────────────
+// Find all PHP locations where a specific Magento event is dispatched
+
+async function findEventDispatchers(eventName) {
+  const root = config.magentoRoot;
+
+  const result = {
+    eventName,
+    dispatchers: [],
+    observerCount: 0
+  };
+
+  const escaped = eventName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // Match eventManager->dispatch('event_name' and similar patterns
+  const dispatchRegex = new RegExp(
+    `dispatch\\s*\\(\\s*['"]${escaped}['"]`
+  );
+
+  // 1. Grep PHP files for exact dispatch calls
+  const phpFiles = await glob('**/*.php', {
+    cwd: root, absolute: true, nodir: true,
+    ignore: ['**/test/**', '**/tests/**', '**/Test/**', '**/Tests/**']
+  });
+
+  for (const phpFile of phpFiles) {
+    let content;
+    try { content = readFileSync(phpFile, 'utf-8'); } catch { continue; }
+    if (!content.includes(eventName)) continue;
+
+    const relativePath = phpFile.replace(root + '/', '');
+    const lines = content.split('\n');
+    const classMatch = content.match(/(?:class|abstract\s+class|trait)\s+(\w+)/);
+    const nsMatch = content.match(/namespace\s+([\w\\]+)/);
+    const className = classMatch ? classMatch[1] : path.basename(phpFile, '.php');
+    const fqcn = nsMatch ? `${nsMatch[1]}\\${className}` : className;
+
+    for (let i = 0; i < lines.length; i++) {
+      if (dispatchRegex.test(lines[i])) {
+        // Find enclosing method
+        let methodName = null;
+        for (let j = i; j >= Math.max(0, i - 30); j--) {
+          const mMatch = lines[j].match(/(?:public|protected|private|static)\s+function\s+(\w+)/);
+          if (mMatch) { methodName = mMatch[1]; break; }
+        }
+
+        // Get surrounding context (2 lines before and after)
+        const ctxStart = Math.max(0, i - 2);
+        const ctxEnd = Math.min(lines.length - 1, i + 2);
+        const context = lines.slice(ctxStart, ctxEnd + 1).map(l => l.trimEnd()).join('\n');
+
+        result.dispatchers.push({
+          path: relativePath,
+          class: fqcn,
+          method: methodName,
+          line: i + 1,
+          snippet: lines[i].trim().slice(0, 200),
+          context: context.slice(0, 500)
+        });
+      }
+    }
+  }
+
+  // 2. Count registered observers for context
+  const eventsFiles = await glob('**/etc/**/events.xml', { cwd: root, absolute: true, nodir: true });
+  for (const file of eventsFiles) {
+    let content;
+    try { content = readFileSync(file, 'utf-8'); } catch { continue; }
+    if (!content.includes(eventName)) continue;
+    const obsMatches = content.match(/<observer\s+/g);
+    if (obsMatches) result.observerCount += obsMatches.length;
+  }
+
+  return result;
+}
+
 // ─── Trace Call Chain ───────────────────────────────────────────
 // Trace internal method execution: method calls, dispatched events, observers
 
@@ -2606,8 +2844,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             default: 10
           },
           moduleFilter: {
-            type: 'string',
-            description: 'Filter results by vendor/module pattern. Supports wildcards and vendor prefix matching. Uses "/" or "_" interchangeably as separator. Examples: "Vendor_*" or "Vendor/*" to show modules from that vendor (also matches vendor-extended names like "Vendor-Extra_*"), "Magento_Catalog" for specific module. Omit to search all modules.'
+            oneOf: [
+              { type: 'string' },
+              { type: 'array', items: { type: 'string' } }
+            ],
+            description: 'Filter results by vendor/module pattern(s). Accepts a single string or array of strings. Supports wildcards and vendor prefix matching. Uses "/" or "_" interchangeably as separator. Examples: "Vendor_*", ["Acme_PaymentGateway", "Acme_FreeShipping"], "Magento_Catalog".'
           },
           expand: {
             type: 'boolean',
@@ -3089,7 +3330,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         properties: {
           methodName: {
             type: 'string',
-            description: 'Method name to find callers for. Examples: "execute", "save", "collectTotals", "copySalesRuleIdsFromParentToDrmaxQuote"'
+            description: 'Method name to find callers for. Examples: "execute", "save", "collectTotals", "copySalesRuleIdsFromParentToChildQuote"'
           },
           className: {
             type: 'string',
@@ -3121,7 +3362,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         properties: {
           className: {
             type: 'string',
-            description: 'Full PHP class name (FQCN) to start tracing from. Examples: "DrmaxMarketplace\\OrderSplit\\Model\\CreateOrder\\CreateChildOrder", "Magento\\Quote\\Model\\QuoteManagement"'
+            description: 'Full PHP class name (FQCN) to start tracing from. Examples: "Vendor\\OrderSplit\\Model\\CreateOrder\\CreateChildOrder", "Magento\\Quote\\Model\\QuoteManagement"'
           },
           methodName: {
             type: 'string',
@@ -3136,6 +3377,38 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ['className', 'methodName']
       }
     },
+    {
+      name: 'magento_trace_data_flow',
+      description: 'Trace how a data attribute flows through the Magento codebase: find all PHP files that set (via magic setter, setData, addData) and get (via magic getter, getData) a specific attribute key. Shows which classes write vs read the attribute, in which methods, and whether XML configs reference it. Use this to understand data dependencies — e.g., who sets custom_discounted_price_incl_tax on Quote\\Address and who reads it.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          attributeKey: {
+            type: 'string',
+            description: 'The snake_case data attribute key to trace. Examples: "custom_discounted_price_incl_tax", "base_grand_total", "custom_free_shipping_price", "subtotal_with_discount"'
+          },
+          modelClass: {
+            type: 'string',
+            description: 'Optional: model class name to prioritize results that reference this class. Examples: "Quote\\Address", "Order", "Product"'
+          }
+        },
+        required: ['attributeKey']
+      }
+    },
+    {
+      name: 'magento_find_event_dispatchers',
+      description: 'Find all PHP locations where a specific Magento event is dispatched via eventManager->dispatch(). Unlike magento_find_event_flow (which shows the full chain: dispatchers+observers+handlers), this tool focuses exclusively on finding WHERE an event is triggered — with exact grep matching, method context, and surrounding code. Use this to answer "does class X dispatch event Y?" or "who triggers this event?".',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          eventName: {
+            type: 'string',
+            description: 'Magento event name to find dispatchers for. Examples: "sales_order_place_after", "custom_discount_rule_validation_before", "checkout_cart_add_product_complete"'
+          }
+        },
+        required: ['eventName']
+      }
+    },
   ]
 }));
 
@@ -3147,7 +3420,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   // ── Warmup guard: index compatibility check or serve process still loading ──
   const indexFreeTools = ['magento_stats', 'magento_analyze_diff', 'magento_complexity',
     'magento_trace_dependency', 'magento_error_parser', 'magento_find_layout',
-    'magento_impact_analysis', 'magento_find_event_flow', 'magento_find_test'];
+    'magento_impact_analysis', 'magento_find_event_flow', 'magento_find_test',
+    'magento_trace_data_flow', 'magento_find_event_dispatchers'];
   if (warmupInProgress && !indexFreeTools.includes(name)) {
     logToFile('REQ', `${name} → blocked (warmup: loading index)`);
     return {
@@ -3330,12 +3604,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         );
         results = rerank(results, { isPlugin: true, pathContains: ['/Plugin/', 'di.xml'] });
 
-        return {
-          content: [{
-            type: 'text',
-            text: formatSearchResults(results.slice(0, 15))
-          }]
-        };
+        // Enrich results with di.xml registration area (frontend/adminhtml/global)
+        const enrichedResults = results.slice(0, 15).map(r => {
+          if (!r.path) return r;
+          let diArea = 'global';
+          if (r.path.includes('/etc/adminhtml/')) diArea = 'adminhtml';
+          else if (r.path.includes('/etc/frontend/')) diArea = 'frontend';
+          else if (r.path.includes('/etc/graphql/')) diArea = 'graphql';
+          else if (r.path.includes('/etc/webapi_rest/')) diArea = 'webapi_rest';
+          else if (r.path.includes('/etc/webapi_soap/')) diArea = 'webapi_soap';
+          else if (r.path.includes('/etc/crontab/')) diArea = 'crontab';
+          return { ...r, diArea };
+        });
+
+        // If targetClass provided, also scan di.xml for explicit registrations
+        let diRegistrations = [];
+        if (args.targetClass) {
+          const fpRoot = config.magentoRoot;
+          const diFiles = await glob('**/etc/**/di.xml', { cwd: fpRoot, absolute: true, nodir: true });
+          const shortTarget = args.targetClass.split('\\').pop();
+          for (const diFile of diFiles) {
+            let content;
+            try { content = readFileSync(diFile, 'utf-8'); } catch { continue; }
+            if (!content.includes(shortTarget)) continue;
+            const relPath = diFile.replace(fpRoot + '/', '');
+            // Find plugin registrations for this target
+            const typeBlockRegex = /<type\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/type>/g;
+            let tm;
+            while ((tm = typeBlockRegex.exec(content)) !== null) {
+              const typeName = tm[1];
+              if (!typeName.includes(shortTarget)) continue;
+              const block = tm[2];
+              const pluginRegex = /<plugin\s+name="([^"]+)"[^>]*type="([^"]+)"[^>]*/g;
+              let pm;
+              while ((pm = pluginRegex.exec(block)) !== null) {
+                let area = 'global';
+                if (relPath.includes('/etc/adminhtml/')) area = 'adminhtml';
+                else if (relPath.includes('/etc/frontend/')) area = 'frontend';
+                else if (relPath.includes('/etc/graphql/')) area = 'graphql';
+                diRegistrations.push({
+                  target: typeName,
+                  pluginName: pm[1],
+                  pluginClass: pm[2],
+                  area,
+                  file: relPath
+                });
+              }
+            }
+          }
+        }
+
+        let text = formatSearchResults(enrichedResults);
+        if (diRegistrations.length > 0) {
+          text += `\n\n### DI Plugin Registrations for ${args.targetClass} (${diRegistrations.length})\n`;
+          for (const reg of diRegistrations) {
+            text += `- **${reg.pluginName}** → \`${reg.pluginClass}\` [${reg.area}] (${reg.file})\n`;
+          }
+        }
+
+        return { content: [{ type: 'text', text }] };
       }
 
       case 'magento_find_observer': {
@@ -4160,6 +4487,78 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: [{ type: 'text', text }] };
       }
 
+      case 'magento_trace_data_flow': {
+        const flowResult = await traceDataFlow(args.attributeKey, args.modelClass);
+
+        let text = `## Data Flow: \`${flowResult.attributeKey}\`\n`;
+        text += `Magic setter: \`${flowResult.setterMethod}()\` · Magic getter: \`${flowResult.getterMethod}()\`\n\n`;
+
+        if (flowResult.setters.length > 0) {
+          text += `### Setters (${flowResult.setters.length})\n`;
+          for (const s of flowResult.setters) {
+            const typeTag = s.type === 'constant' ? ' [const]' : '';
+            const methodTag = s.method ? `::${s.method}` : '';
+            text += `- \`${s.class}${methodTag}\`${typeTag} (${s.path}:${s.line})\n`;
+            if (s.snippet) text += `  \`${s.snippet}\`\n`;
+          }
+          text += '\n';
+        } else {
+          text += '### Setters\n_No setters found._\n\n';
+        }
+
+        if (flowResult.getters.length > 0) {
+          text += `### Getters (${flowResult.getters.length})\n`;
+          for (const g of flowResult.getters) {
+            const methodTag = g.method ? `::${g.method}` : '';
+            text += `- \`${g.class}${methodTag}\` (${g.path}:${g.line})\n`;
+            if (g.snippet) text += `  \`${g.snippet}\`\n`;
+          }
+          text += '\n';
+        } else {
+          text += '### Getters\n_No getters found._\n\n';
+        }
+
+        if (flowResult.xmlReferences.length > 0) {
+          text += `### XML References (${flowResult.xmlReferences.length})\n`;
+          for (const x of flowResult.xmlReferences) {
+            text += `- ${x.path}:${x.line}\n  \`${x.snippet}\`\n`;
+          }
+        }
+
+        return { content: [{ type: 'text', text }] };
+      }
+
+      case 'magento_find_event_dispatchers': {
+        const dispResult = await findEventDispatchers(args.eventName);
+
+        let text = `## Event Dispatchers: \`${dispResult.eventName}\`\n\n`;
+
+        if (dispResult.dispatchers.length > 0) {
+          text += `Found ${dispResult.dispatchers.length} dispatch location(s)`;
+          if (dispResult.observerCount > 0) {
+            text += ` (${dispResult.observerCount} observer(s) registered)`;
+          }
+          text += '.\n\n';
+
+          for (const d of dispResult.dispatchers) {
+            const methodTag = d.method ? `::${d.method}` : '';
+            text += `### \`${d.class}${methodTag}\`\n`;
+            text += `**File:** ${d.path}:${d.line}\n`;
+            if (d.context) {
+              text += '```php\n' + d.context + '\n```\n';
+            }
+            text += '\n';
+          }
+        } else {
+          text += '_No dispatch() calls found for this event._\n';
+          if (dispResult.observerCount > 0) {
+            text += `\nNote: ${dispResult.observerCount} observer(s) are registered for this event — it may be dispatched by Magento core or a module not in the scanned path.\n`;
+          }
+        }
+
+        return { content: [{ type: 'text', text }] };
+      }
+
       default:
         return {
           content: [{