magector 2.5.1 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magector",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "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.5.1",
-    "@magector/cli-linux-x64": "2.5.1",
-    "@magector/cli-linux-arm64": "2.5.1",
-    "@magector/cli-win32-x64": "2.5.1"
+    "@magector/cli-darwin-arm64": "2.6.0",
+    "@magector/cli-linux-x64": "2.6.0",
+    "@magector/cli-linux-arm64": "2.6.0",
+    "@magector/cli-win32-x64": "2.6.0"
   },
   "keywords": [
     "magento",

package/src/mcp-server.js

@@ -1004,6 +1004,41 @@ function readMethodSnippet(filePath, methodName, maxLines = 15) {
   return null;
 }
 
+/**
+ * Read the FULL method body using brace-counting to find the closing brace.
+ * Unlike readMethodSnippet (fixed N lines), this extracts the complete method
+ * regardless of length, up to a safety limit.
+ * @param {string} filePath - absolute or relative PHP file path
+ * @param {string} methodName - method name to find
+ * @param {number} maxLines - safety limit to prevent reading huge methods (default: 60)
+ * @returns {string|null} complete method source or null if not found
+ */
+function readFullMethodBody(filePath, methodName, maxLines = 60) {
+  const absPath = filePath.startsWith('/') ? filePath : path.join(config.magentoRoot, filePath);
+  let content;
+  try { content = readFileSync(absPath, 'utf-8'); } catch { return null; }
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`function ${methodName}(`)) {
+      // Use brace counting to find the complete method body
+      let braceCount = 0;
+      let started = false;
+      for (let j = i; j < lines.length && j < i + maxLines; j++) {
+        for (const ch of lines[j]) {
+          if (ch === '{') { braceCount++; started = true; }
+          if (ch === '}') braceCount--;
+        }
+        if (started && braceCount <= 0) {
+          return lines.slice(i, j + 1).join('\n');
+        }
+      }
+      // Safety: if closing brace not found within maxLines, return what we have
+      return lines.slice(i, Math.min(i + maxLines, lines.length)).join('\n');
+    }
+  }
+  return null;
+}
+
 /**
  * Parse all fieldset.xml files in the Magento root.
  * Returns array of { file, scope, fieldset, fields: [{ field, aspect }] }.
@@ -1561,15 +1596,23 @@ function formatSearchResults(results) {
     if (r.isBlock) badges.push('block');
     if (badges.length > 0) entry.badges = badges;
 
+    // Only include verbose content (snippet, codePreview) for top-ranked results
+    // to reduce token consumption — lower-ranked results just show metadata
+    const isTopRanked = i < 3;
+
     // Snippet — first 300 chars of indexed content for quick assessment
-    if (r.searchText) {
+    if (isTopRanked && r.searchText) {
       entry.snippet = r.searchText.length > 300
         ? r.searchText.slice(0, 300) + '...'
         : r.searchText;
     }
 
+    // Full method body — attached by magento_find_method for complete understanding
+    if (r.fullMethodBody) {
+      entry.codePreview = r.fullMethodBody;
+    }
     // Code preview — read actual source lines for PHP files with known class/method
-    if (r.path && (r.path.endsWith('.php') || r.path.endsWith('.phtml'))) {
+    else if (isTopRanked && r.path && (r.path.endsWith('.php') || r.path.endsWith('.phtml'))) {
       if (r.methodName) {
         const preview = readMethodSnippet(r.path, r.methodName, 10);
         if (preview) entry.codePreview = preview;
@@ -1600,6 +1643,47 @@ function formatSearchResults(results) {
   return JSON.stringify({ results: formatted, count: formatted.length });
 }
 
+// ─── DI XML Session Cache ─────────────────────────────────────
+
+/**
+ * Session-level cache for parsed di.xml file contents.
+ * Avoids re-reading and re-globbing di.xml files across multiple tool calls
+ * (findDiWiring, traceDependency, magento_find_plugin all scan di.xml).
+ */
+const diXmlCache = {
+  /** @type {Map<string, string>} path → file content */
+  files: new Map(),
+  /** @type {string[]|null} cached list of all di.xml absolute paths */
+  paths: null,
+  /** @type {string|null} root used for caching (invalidate if root changes) */
+  root: null
+};
+
+/**
+ * Get all di.xml file paths and their contents, using session cache.
+ * @param {string} root - Magento root path
+ * @returns {Promise<Array<{absPath: string, relPath: string, content: string}>>}
+ */
+async function getDiXmlFiles(root) {
+  if (diXmlCache.root !== root || !diXmlCache.paths) {
+    diXmlCache.root = root;
+    diXmlCache.paths = await glob('**/etc/**/di.xml', { cwd: root, absolute: true, nodir: true });
+    diXmlCache.files.clear();
+  }
+  const results = [];
+  for (const absPath of diXmlCache.paths) {
+    let content = diXmlCache.files.get(absPath);
+    if (content === undefined) {
+      try { content = readFileSync(absPath, 'utf-8'); } catch { content = null; }
+      diXmlCache.files.set(absPath, content);
+    }
+    if (content !== null) {
+      results.push({ absPath, relPath: absPath.replace(root + '/', ''), content });
+    }
+  }
+  return results;
+}
+
 // ─── DI Dependency Tracing ─────────────────────────────────────
 
 /**
@@ -1608,7 +1692,7 @@ function formatSearchResults(results) {
  */
 async function traceDependency(className, direction = 'both') {
   const root = config.magentoRoot;
-  const diFiles = await glob('**/etc/**/di.xml', { cwd: root, absolute: true, nodir: true });
+  const diFiles = await getDiXmlFiles(root);
   const classLower = className.toLowerCase();
   const classShort = className.split('\\').pop().toLowerCase();
 
@@ -1621,13 +1705,7 @@ async function traceDependency(className, direction = 'both') {
     totalDiFiles: diFiles.length
   };
 
-  for (const diFile of diFiles) {
-    let content;
-    try {
-      content = readFileSync(diFile, 'utf-8');
-    } catch { continue; }
-
-    const relativePath = diFile.replace(root + '/', '');
+  for (const { content, relPath: relativePath } of diFiles) {
 
     if (direction === 'resolve' || direction === 'both') {
       // Find preferences: <preference for="ClassName" type="Implementation"/>
@@ -2553,6 +2631,21 @@ async function findDiWiring(className) {
   const root = config.magentoRoot;
   const shortName = className.split('\\').pop();
   const shortLower = shortName.toLowerCase();
+  // When a FQCN is provided (contains \), use it for precise matching
+  const hasFqcn = className.includes('\\');
+  // Normalize FQCN for XML matching: di.xml uses backslash-escaped names
+  const fqcnNormalized = hasFqcn ? className.replace(/\\\\/g, '\\') : null;
+  const fqcnLower = fqcnNormalized ? fqcnNormalized.toLowerCase() : null;
+
+  // Helper: check if a di.xml class name matches the requested class.
+  // When FQCN is available, require full namespace match; otherwise fall back to short name.
+  function matchesClass(xmlClassName) {
+    const xmlLower = xmlClassName.toLowerCase().replace(/\\\\/g, '\\');
+    if (fqcnLower) {
+      return xmlLower === fqcnLower || xmlLower.endsWith('\\' + fqcnLower);
+    }
+    return xmlLower.includes(shortLower);
+  }
 
   const result = {
     className,
@@ -2564,24 +2657,20 @@ async function findDiWiring(className) {
     totalDiFiles: 0
   };
 
-  const diFiles = await glob('**/etc/**/di.xml', { cwd: root, absolute: true, nodir: true });
+  const diFiles = await getDiXmlFiles(root);
   result.totalDiFiles = diFiles.length;
 
-  for (const diFile of diFiles) {
-    let content;
-    try { content = readFileSync(diFile, 'utf-8'); } catch { continue; }
-    const relativePath = diFile.replace(root + '/', '');
+  for (const { content, relPath: relativePath } of diFiles) {
     const contentLower = content.toLowerCase();
 
+    // Quick pre-filter: skip files that don't contain the short name at all
     if (!contentLower.includes(shortLower)) continue;
 
     // 1. Preferences where this class is the "for" or "type"
     const prefRegex = /<preference\s+for="([^"]+)"\s+type="([^"]+)"\s*\/?>/g;
     let m;
     while ((m = prefRegex.exec(content)) !== null) {
-      const forLower = m[1].toLowerCase();
-      const typeLower = m[2].toLowerCase();
-      if (forLower.includes(shortLower) || typeLower.includes(shortLower)) {
+      if (matchesClass(m[1]) || matchesClass(m[2])) {
         result.preferences.push({ for: m[1], type: m[2], file: relativePath });
       }
     }
@@ -2591,10 +2680,9 @@ async function findDiWiring(className) {
     let typeMatch;
     while ((typeMatch = typeBlockRegex.exec(content)) !== null) {
       const typeName = typeMatch[1];
-      const typeNameLower = typeName.toLowerCase();
       const typeBlock = typeMatch[2];
 
-      if (!typeNameLower.includes(shortLower)) continue;
+      if (!matchesClass(typeName)) continue;
 
       // Plugins
       const pluginRegex = /<plugin\s+name="([^"]+)"[^>]*type="([^"]+)"[^>]*/g;
@@ -2641,7 +2729,7 @@ async function findDiWiring(className) {
     const vtRegex = /<virtualType\s+name="([^"]+)"[^>]*type="([^"]+)"[^>]*(?:\/>|>([\s\S]*?)<\/virtualType>)/g;
     while ((m = vtRegex.exec(content)) !== null) {
       const vtType = m[2];
-      if (!vtType.toLowerCase().includes(shortLower)) continue;
+      if (!matchesClass(vtType)) continue;
       const vtEntry = { name: m[1], type: vtType, file: relativePath };
       if (m[3]) {
         const argRegex = /<argument\s+name="([^"]+)"[^>]*xsi:type="([^"]+)"[^>]*>([^<]*)<\/argument>/g;
@@ -2657,6 +2745,7 @@ async function findDiWiring(className) {
   }
 
   // 4. Constructor arguments from PHP class
+  // When FQCN is provided, verify namespace matches to avoid class name collisions
   const phpFiles = await glob(`**/${shortName}.php`, { cwd: root, absolute: true, nodir: true });
   for (const phpFile of phpFiles) {
     let content;
@@ -2664,6 +2753,17 @@ async function findDiWiring(className) {
     const classMatch = content.match(/(?:class|abstract\s+class)\s+(\w+)/);
     if (!classMatch || classMatch[1] !== shortName) continue;
 
+    // FQCN namespace verification: when a full class name was provided,
+    // check that the PHP file's namespace matches to avoid collisions
+    // (e.g., two different ViewPlugin classes in different modules)
+    if (fqcnNormalized) {
+      const nsMatch = content.match(/namespace\s+([\w\\]+)\s*;/);
+      if (nsMatch) {
+        const fileFqcn = (nsMatch[1] + '\\' + shortName).toLowerCase();
+        if (fileFqcn !== fqcnLower) continue; // Wrong class, skip
+      }
+    }
+
     const ctorMatch = content.match(/function\s+__construct\s*\(([\s\S]*?)\)\s*[{:]/);
     if (ctorMatch) {
       const paramRegex = /(?:([\w\\]+)\s+)?(\$\w+)/g;
@@ -2672,6 +2772,7 @@ async function findDiWiring(className) {
         result.constructorArguments.push({ typeHint: pm[1] || null, variable: pm[2] });
       }
     }
+    result.constructorSourceFile = phpFile.replace(root + '/', '');
     break;
   }
 
@@ -3946,7 +4047,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return {
           content: [{
             type: 'text',
-            text: formatSearchResults(results.slice(0, args.limit || 10))
+            text: formatSearchResults(results.slice(0, args.limit || 5))
           }]
         };
       }
@@ -3963,7 +4064,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return {
           content: [{
             type: 'text',
-            text: formatSearchResults(results.slice(0, 5))
+            text: formatSearchResults(results.slice(0, 3))
           }]
         };
       }
@@ -3992,10 +4093,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           if (r.methodName?.toLowerCase() === methodLower) bonus += 0.3;
           return { ...r, score: (r.score || 0) + bonus };
         }).sort((a, b) => b.score - a.score);
+        // Attach full method body to each result for complete understanding
+        const sliced = results.slice(0, 5);
+        for (const r of sliced) {
+          if (r.path && r.path.endsWith('.php')) {
+            const body = readFullMethodBody(r.path, args.methodName);
+            if (body) r.fullMethodBody = body;
+          }
+        }
         return {
           content: [{
             type: 'text',
-            text: formatSearchResults(results.slice(0, 10))
+            text: formatSearchResults(sliced)
           }]
         };
       }
@@ -4093,18 +4202,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           return { ...r, diArea };
         });
 
-        // If targetClass provided, also scan di.xml for explicit registrations
+        // If targetClass provided, also scan di.xml for explicit registrations (using session cache)
         let diRegistrations = [];
         if (args.targetClass) {
           const fpRoot = config.magentoRoot;
-          const diFiles = await glob('**/etc/**/di.xml', { cwd: fpRoot, absolute: true, nodir: true });
+          const diFiles = await getDiXmlFiles(fpRoot);
           // Normalize target class for matching (both \ and \\)
           const normalizedTarget = args.targetClass.replace(/\\\\/g, '\\');
-          for (const diFile of diFiles) {
-            let content;
-            try { content = readFileSync(diFile, 'utf-8'); } catch { continue; }
+          for (const { content, relPath } of diFiles) {
             if (!content.includes(normalizedTarget)) continue;
-            const relPath = diFile.replace(fpRoot + '/', '');
             // Find plugin registrations for this target
             const typeBlockRegex = /<type\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/type>/g;
             let tm;
@@ -4139,14 +4245,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }
         }
 
-        // Resolve plugin methods for DI registrations
-        const fpRoot = args.targetClass ? config.magentoRoot : null;
+        // Resolve plugin methods + method bodies for DI registrations
+        const fpRoot2 = args.targetClass ? config.magentoRoot : null;
         for (const reg of diRegistrations) {
-          if (reg.pluginClass && fpRoot) {
-            const pluginFile = findClassFile(fpRoot, reg.pluginClass);
+          if (reg.pluginClass && fpRoot2) {
+            const pluginFile = findClassFile(fpRoot2, reg.pluginClass);
             if (pluginFile) {
               reg.methods = extractPluginMethods(pluginFile);
-              reg.resolvedFile = pluginFile.replace(fpRoot + '/', '');
+              reg.resolvedFile = pluginFile.replace(fpRoot2 + '/', '');
+              // Read full method bodies so the agent sees actual code without follow-up calls
+              for (const m of reg.methods) {
+                const body = readFullMethodBody(pluginFile, m.name);
+                if (body) m.body = body;
+              }
             }
           }
         }
@@ -4164,6 +4275,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (reg.methods?.length > 0) {
               for (const m of reg.methods) {
                 text += `  - \`${m.type}\` **${m.targetMethod}** → \`${m.name}()\`\n`;
+                if (m.body) {
+                  const indentedBody = m.body.split('\n').join('\n    ');
+                  text += '    ' + '```php\n    ' + indentedBody + '\n    ' + '```\n';
+                }
               }
             }
           }
@@ -5394,6 +5509,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 for (const o of flow.observers.slice(0, 10)) text += `- ${o.name}: ${o.instance} (${o.file})\n`;
                 break;
               }
+              case 'magento_find_di_wiring': {
+                const wiring = await findDiWiring(a.className);
+                text = `Prefs: ${wiring.preferences.length}, Plugins: ${wiring.plugins.length}, VTs: ${wiring.virtualTypes.length}, Ctor: ${wiring.constructorArguments.length}\n`;
+                for (const p of wiring.plugins.slice(0, 5)) text += `- plugin: ${p.pluginName} → ${p.pluginClass}\n`;
+                for (const c of wiring.constructorArguments.slice(0, 10)) text += `- ctor: ${c.typeHint || '?'} ${c.variable}\n`;
+                if (wiring.constructorSourceFile) text += `Source: ${wiring.constructorSourceFile}\n`;
+                break;
+              }
+              case 'magento_find_method': {
+                const qr = `method ${a.methodName} function ${a.className || ''}`.trim();
+                const raw = await rustSearchAsync(qr, 50);
+                const ml = a.methodName.toLowerCase();
+                let res = raw.map(normalizeResult).filter(r =>
+                  r.methodName?.toLowerCase() === ml || r.methods?.some(m => m.toLowerCase() === ml)
+                );
+                for (const r of res.slice(0, 5)) {
+                  if (r.path?.endsWith('.php')) {
+                    const body = readFullMethodBody(r.path, a.methodName);
+                    if (body) r.fullMethodBody = body;
+                  }
+                }
+                text = formatSearchResults(res.slice(0, 5));
+                break;
+              }
               default:
                 text = `Unsupported batch tool: ${q.tool}`;
             }