magector 2.5.2 → 2.6.1

package/package.json

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

package/src/mcp-server.js

@@ -202,7 +202,16 @@ function releasePrimaryLock() {
  * Write the serve process PID to disk so future instances can clean up orphans.
  */
 function writePidFile(pid) {
-  try { writeFileSync(PID_PATH, String(pid)); } catch {}
+  try { writeFileSync(PID_PATH, `${pid}\n${__pkg.version}`); } catch {}
+}
+
+function getServePidVersion() {
+  try {
+    if (!existsSync(PID_PATH)) return null;
+    const content = readFileSync(PID_PATH, 'utf-8').trim();
+    const lines = content.split('\n');
+    return lines[1] || null;
+  } catch { return null; }
 }
 
 function removePidFile() {
@@ -809,20 +818,29 @@ async function rustSearchAsync(query, limit = 10) {
   if (queryFn) {
     try {
       const resp = await queryFn('search', { query, limit });
-      if (resp.ok && Array.isArray(resp.data)) {
+      if (resp.ok && Array.isArray(resp.data) && resp.data.length > 0) {
         cacheSet(cacheKey, resp.data);
         return resp.data;
       }
+      // Serve returned empty results — fall through to execFileSync
+      // This catches stale serve processes with wrong/empty index
+      if (resp.ok && Array.isArray(resp.data) && resp.data.length === 0) {
+        logToFile('WARN', `Serve returned 0 results for "${query}" — trying execFileSync fallback`);
+      }
     } catch (err) {
       logToFile('WARN', `Serve query failed, falling back to execFileSync: ${err.message}`);
     }
   }
 
-  // Fallback: cold-start execFileSync
+  // Fallback: cold-start execFileSync (always works if CLI works)
   logToFile('INFO', `Using execFileSync fallback for search: "${query}"`);
   try {
     const result = rustSearchSync(query, limit);
-    return Array.isArray(result) ? result : [];
+    const arr = Array.isArray(result) ? result : [];
+    if (arr.length > 0) {
+      cacheSet(cacheKey, arr);
+    }
+    return arr;
   } catch (err) {
     logToFile('WARN', `execFileSync fallback failed: ${err.message}`);
     return [];
@@ -1596,8 +1614,12 @@ 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;
@@ -1608,7 +1630,7 @@ function formatSearchResults(results) {
       entry.codePreview = r.fullMethodBody;
     }
     // Code preview — read actual source lines for PHP files with known class/method
-    else 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;
@@ -1639,6 +1661,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 ─────────────────────────────────────
 
 /**
@@ -1647,7 +1710,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();
 
@@ -1660,13 +1723,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"/>
@@ -2618,13 +2675,10 @@ 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
@@ -4011,7 +4065,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))
           }]
         };
       }
@@ -4028,7 +4082,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return {
           content: [{
             type: 'text',
-            text: formatSearchResults(results.slice(0, 5))
+            text: formatSearchResults(results.slice(0, 3))
           }]
         };
       }
@@ -4058,7 +4112,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           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, 10);
+        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);
@@ -4166,24 +4220,27 @@ 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; }
-            if (!content.includes(normalizedTarget)) continue;
-            const relPath = diFile.replace(fpRoot + '/', '');
+          const isFqcn = normalizedTarget.includes('\\');
+          const shortTarget = normalizedTarget.split('\\').pop().toLowerCase();
+          for (const { content, relPath } of diFiles) {
+            if (!content.includes(isFqcn ? normalizedTarget : args.targetClass)) continue;
             // 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].replace(/\\\\/g, '\\');
-              if (typeName !== normalizedTarget) continue;
+              // FQCN: exact match. Short name: match if type ends with the short name
+              const typeMatches = isFqcn
+                ? typeName === normalizedTarget
+                : typeName.split('\\').pop().toLowerCase() === shortTarget;
+              if (!typeMatches) continue;
               const block = tm[2];
               const pluginRegex = /<plugin\s+([^/>]*)\/?>/g;
               let pm;
@@ -4212,14 +4269,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;
+              }
             }
           }
         }
@@ -4237,6 +4299,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';
+                }
               }
             }
           }
@@ -4246,19 +4312,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'magento_find_observer': {
-        const query = `event ${args.eventName} observer`;
-        const raw = await rustSearchAsync(query, 30);
-        let results = raw.map(normalizeResult).filter(r =>
-          r.isObserver || r.path?.includes('/Observer/') || r.path?.includes('events.xml')
-        );
-        results = rerank(results, { isObserver: true, pathContains: ['events.xml', '/Observer/'] });
+        // Primary: parse events.xml for exact event name match (structural, not semantic)
+        const eventFlow = await traceEventFlow(args.eventName);
+        let text = '';
+
+        if (eventFlow.observers.length > 0) {
+          text += `### Observers for \`${args.eventName}\` (${eventFlow.observers.length})\n\n`;
+          for (const obs of eventFlow.observers) {
+            text += `- **${obs.name}** → \`${obs.instance}::${obs.method}()\` (${obs.file})\n`;
+          }
+          if (eventFlow.observerDetails.length > 0) {
+            text += `\n### Observer PHP Files\n`;
+            for (const det of eventFlow.observerDetails) {
+              text += `- \`${det.instance}\` → ${det.path}\n`;
+            }
+          }
+        }
 
-        return {
-          content: [{
-            type: 'text',
-            text: formatSearchResults(results.slice(0, 15))
-          }]
-        };
+        // Fallback: semantic search if events.xml parsing found nothing
+        if (eventFlow.observers.length === 0) {
+          const query = `event ${args.eventName} observer`;
+          const raw = await rustSearchAsync(query, 30);
+          let results = raw.map(normalizeResult).filter(r =>
+            r.isObserver || r.path?.includes('/Observer/') || r.path?.includes('events.xml')
+          );
+          results = rerank(results, { isObserver: true, pathContains: ['events.xml', '/Observer/'] });
+          text = formatSearchResults(results.slice(0, 15));
+        }
+
+        return { content: [{ type: 'text', text }] };
       }
 
       case 'magento_find_preference': {
@@ -5491,6 +5573,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 text = formatSearchResults(res.slice(0, 5));
                 break;
               }
+              case 'magento_module_structure': {
+                const raw = await rustSearchAsync(a.moduleName, 200);
+                const modulePath = a.moduleName.replace('_', '/') + '/';
+                const parts = a.moduleName.split('_');
+                const vendorPath = parts.length === 2 ? `module-${parts[1].toLowerCase()}/` : '';
+                const res = raw.map(normalizeResult).filter(r => {
+                  const p = r.path || '';
+                  const mod = r.module || '';
+                  return mod === a.moduleName || p.includes(modulePath) || (vendorPath && p.toLowerCase().includes(vendorPath));
+                });
+                text = `Module: ${a.moduleName} (${res.length} files)\n`;
+                const cats = { controllers: '/Controller/', models: '/Model/', plugins: '/Plugin/', observers: '/Observer/', api: '/Api/' };
+                for (const [cat, pattern] of Object.entries(cats)) {
+                  const matches = res.filter(r => r.path?.includes(pattern));
+                  if (matches.length > 0) {
+                    text += `${cat}: ${matches.length} (${matches.slice(0, 3).map(r => r.className || r.path?.split('/').pop()).join(', ')})\n`;
+                  }
+                }
+                break;
+              }
+              case 'magento_find_observer': {
+                const flow = await traceEventFlow(a.eventName);
+                text = `Observers: ${flow.observers.length}\n`;
+                for (const o of flow.observers.slice(0, 10)) {
+                  text += `- ${o.name}: ${o.instance}::${o.method}() (${o.file})\n`;
+                }
+                break;
+              }
               default:
                 text = `Unsupported batch tool: ${q.tool}`;
             }
@@ -5583,6 +5693,16 @@ async function main() {
   try {
     let role = 'secondary';
 
+    // Kill stale serve process if version mismatch (e.g., user upgraded Magector)
+    const staleVersion = getServePidVersion();
+    if (staleVersion && staleVersion !== __pkg.version) {
+      logToFile('WARN', `Serve process version mismatch: ${staleVersion} vs ${__pkg.version} — killing stale process`);
+      console.error(`Killing stale serve process (version ${staleVersion}, current ${__pkg.version})`);
+      killStaleServeProcess();
+      // Remove stale socket so we don't connect to it
+      try { if (existsSync(SOCK_PATH)) unlinkSync(SOCK_PATH); } catch {}
+    }
+
     const connected = await tryConnectSocket();
     if (connected) {
       logToFile('INFO', 'Joined existing serve process via socket (secondary)');