magector 2.16.5 → 2.16.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magector",
-  "version": "2.16.5",
+  "version": "2.16.7",
   "description": "Semantic code search for Magento 2 — index, search, MCP server",
   "type": "module",
   "main": "src/mcp-server.js",
@@ -33,10 +33,10 @@
     "ruvector": "^0.1.96"
   },
   "optionalDependencies": {
-    "@magector/cli-darwin-arm64": "2.16.5",
-    "@magector/cli-linux-x64": "2.16.5",
-    "@magector/cli-linux-arm64": "2.16.5",
-    "@magector/cli-win32-x64": "2.16.5"
+    "@magector/cli-darwin-arm64": "2.16.7",
+    "@magector/cli-linux-x64": "2.16.7",
+    "@magector/cli-linux-arm64": "2.16.7",
+    "@magector/cli-win32-x64": "2.16.7"
   },
   "keywords": [
     "magento",

package/src/mcp-server.js

@@ -4901,11 +4901,14 @@ const _callToolHandler = async (request) => {
             let tm;
             while ((tm = typeBlockRegex.exec(content)) !== null) {
               const typeName = tm[1].replace(/\\\\/g, '\\');
-              // FQCN: exact match. Short name: match if type ends with the short name
-              const typeMatches = isFqcn
+              // FQCN: exact match. Short name: match last segment OR any namespace segment
+              // (catches sub-namespace types like Payment\State\CaptureCommand when searching for "Payment")
+              const typeSegments = typeName.split('\\').map(s => s.toLowerCase());
+              const isExactMatch = isFqcn
                 ? typeName === normalizedTarget
-                : typeName.split('\\').pop().toLowerCase() === shortTarget;
-              if (!typeMatches) continue;
+                : typeSegments[typeSegments.length - 1] === shortTarget;
+              const isSubNamespace = !isFqcn && !isExactMatch && typeSegments.includes(shortTarget);
+              if (!isExactMatch && !isSubNamespace) continue;
               const block = tm[2];
               const pluginRegex = /<plugin\s+([^/>]*)\/?>/g;
               let pm;
@@ -4926,6 +4929,7 @@ const _callToolHandler = async (request) => {
                   pluginClass: attrs.type || '',
                   disabled: attrs.disabled === 'true',
                   sortOrder: attrs.sortOrder || null,
+                  isSubNamespace,
                   area,
                   file: relPath
                 });
@@ -4942,8 +4946,9 @@ const _callToolHandler = async (request) => {
             if (pluginFile) {
               reg.methods = extractPluginMethods(pluginFile);
               reg.resolvedFile = pluginFile.replace(fpRoot2 + '/', '');
-              // Read method bodies — only for targetMethod if specified (reduces token bloat)
-              const methodsToRead = args.targetMethod
+              // Read method bodies — for exact matches, filter by targetMethod to reduce bloat
+              // For sub-namespace matches, read ALL bodies (intercepted method name may differ)
+              const methodsToRead = (args.targetMethod && !reg.isSubNamespace)
                 ? reg.methods.filter(m => m.targetMethod === args.targetMethod)
                 : reg.methods;
               for (const m of methodsToRead) {
@@ -4955,12 +4960,27 @@ const _callToolHandler = async (request) => {
         }
 
         let text = formatSearchResults(enrichedResults);
+        const exactRegs = diRegistrations.filter(r => !r.isSubNamespace);
+        const subNsRegs = diRegistrations.filter(r => r.isSubNamespace);
         if (diRegistrations.length > 0) {
-          text += `\n\n### DI Plugin Registrations for ${args.targetClass} (${diRegistrations.length})\n`;
-          for (const reg of diRegistrations) {
+          if (exactRegs.length > 0) {
+            text += `\n\n### DI Plugin Registrations for ${args.targetClass} (${exactRegs.length})\n`;
+          }
+          if (subNsRegs.length > 0) {
+            if (exactRegs.length === 0) text += '\n';
+            text += `\n### Plugins on ${args.targetClass} sub-classes (${subNsRegs.length})\n`;
+            text += `> These intercept classes in the \\${args.targetClass}\\ namespace subtree — operations, state commands, etc.\n\n`;
+          }
+          const orderedRegs = [...exactRegs, ...subNsRegs];
+          let inSubNs = false;
+          for (const reg of orderedRegs) {
+            if (!inSubNs && reg.isSubNamespace) {
+              inSubNs = true;
+            }
             const disabledTag = reg.disabled ? ' **[DISABLED]**' : '';
             const sortTag = reg.sortOrder ? ` (sortOrder: ${reg.sortOrder})` : '';
-            text += `- **${reg.pluginName}** → \`${reg.pluginClass}\` [${reg.area}]${sortTag}${disabledTag} (${reg.file})\n`;
+            const targetTag = reg.isSubNamespace ? ` on \`${reg.target.split('\\').pop()}\`` : '';
+            text += `- **${reg.pluginName}**${targetTag} → \`${reg.pluginClass}\` [${reg.area}]${sortTag}${disabledTag} (${reg.file})\n`;
             if (reg.resolvedFile) {
               text += `  PHP: \`${reg.resolvedFile}\`\n`;
             }
@@ -6257,25 +6277,30 @@ const _callToolHandler = async (request) => {
                     while ((tm = typeBlockRegex.exec(diContent)) !== null) {
                       if (regCount >= 8) break;
                       const typeName = tm[1].replace(/\\\\/g, '\\');
-                      const typeMatches = isFqcn ? typeName === normalizedTarget : typeName.split('\\').pop().toLowerCase() === shortTarget;
-                      if (!typeMatches) continue;
+                      const batchSegs = typeName.split('\\').map(s => s.toLowerCase());
+                      const isExact = isFqcn ? typeName === normalizedTarget : batchSegs[batchSegs.length - 1] === shortTarget;
+                      const isSubNs = !isFqcn && !isExact && batchSegs.includes(shortTarget);
+                      if (!isExact && !isSubNs) continue;
                       const block = tm[2];
-                      const pluginRegex = /<plugin\s+([^/>]*)\/?>/g;
+                      const pluginRegex2 = /<plugin\s+([^/>]*)\/?>/g;
                       let pm;
-                      while ((pm = pluginRegex.exec(block)) !== null) {
-                        if (regCount >= 8) break;
+                      while ((pm = pluginRegex2.exec(block)) !== null) {
+                        if (regCount >= 12) break;
                         const attrs = {};
                         const localAttrRe = /(\w+)="([^"]*)"/g;
                         let am2;
                         while ((am2 = localAttrRe.exec(pm[1])) !== null) attrs[am2[1]] = am2[2];
                         const disabled = attrs.disabled === 'true' ? ' [DISABLED]' : '';
-                        text += `- **${attrs.name || '?'}** → \`${attrs.type || '?'}\`${disabled} (${relPath})\n`;
-                        // Only read method bodies for plugins that intercept the targetMethod
-                        if (attrs.type && a.targetMethod) {
+                        const subTag = isSubNs ? ` on \`${typeName.split('\\').pop()}\`` : '';
+                        text += `- **${attrs.name || '?'}**${subTag} → \`${attrs.type || '?'}\`${disabled} (${relPath})\n`;
+                        // Read method bodies: exact matches filter by targetMethod; sub-namespace reads ALL
+                        if (attrs.type) {
                           const pFile = findClassFile(config.magentoRoot, attrs.type);
                           if (pFile) {
                             const methods = extractPluginMethods(pFile);
-                            const relevant = methods.filter(m => m.targetMethod === a.targetMethod);
+                            const relevant = (a.targetMethod && !isSubNs)
+                              ? methods.filter(m => m.targetMethod === a.targetMethod)
+                              : methods;
                             for (const m of relevant) {
                               const body = readFullMethodBody(pFile, m.name);
                               text += `  - \`${m.type}\` **${m.targetMethod}** → \`${m.name}()\`\n`;

package/src/templates/claude-md.js

@@ -38,6 +38,14 @@ This project is indexed with Magector. Use the MCP tools below to search the cod
 - Include Magento terms: "plugin for save", "observer for order place"
 - Be specific: "customer address validation before checkout" not just "validation"
 
+## Analysis Patterns
+
+### Negative match audit
+When \`magento_grep\` finds a bug pattern in only SOME files of a known group (e.g. \`orderRepository->save()\` in 5 of 8 transition handlers), always read the files that DON'T match to understand why they differ. This narrows the fix scope — files with a different code path may not need fixing.
+
+### Follow up DI listings with code reads
+When \`magento_trace_dependency\` or \`magento_find_plugin\` returns a list of plugins/preferences, don't stop at the names. Use \`magento_read\` or \`Read\` to inspect the actual implementation of each — the root cause is often in a specific condition inside the plugin code, not in the DI wiring itself.
+
 ## Re-indexing
 
 After significant code changes, re-index:

package/src/templates/cursor-rules-mdc.js

@@ -40,6 +40,11 @@ Before reading files manually, ALWAYS use Magector MCP tools to find relevant co
 - Include Magento terms: "plugin for save", "observer for order place", "checkout totals collector"
 - Be specific: "customer address validation before checkout" not just "validation"
 
+## Analysis Patterns
+
+- **Negative match audit:** When \`magento_grep\` finds a bug pattern in only SOME files of a group, always read the non-matching files to understand why they differ. This narrows the fix scope.
+- **Follow up DI listings with code reads:** When \`magento_trace_dependency\` or \`magento_find_plugin\` returns plugin/preference names, always read the actual implementation. The root cause is often in a condition inside the code, not in the DI wiring.
+
 ## Magento Development Patterns
 
 - Always check for existing plugins before modifying core behavior