magector 2.7.0 → 2.8.0

package/package.json

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

package/src/mcp-server.js

@@ -2303,6 +2303,33 @@ async function analyzeImpact(className) {
     ...diTrace.virtualTypes.map(v => ({ type: 'virtualType', file: v.file, detail: `${v.name} extends ${v.type}` })),
     ...diTrace.argumentOverrides.map(a => ({ type: 'argument', file: a.file, detail: `${a.target}.${a.argumentName}` }))
   ];
+  // Also find where this class is used AS a plugin/preference/virtualType implementation
+  if (references.diXmlReferences.length === 0 && root) {
+    const diFiles = await getDiXmlFiles(root);
+    for (const { content, relPath } of diFiles) {
+      if (!content.toLowerCase().includes(shortName.toLowerCase())) continue;
+      // Check if class appears as plugin type
+      const pluginTypeRegex = /<plugin\s+[^>]*type="([^"]+)"[^>]*\/?>/g;
+      let pm;
+      while ((pm = pluginTypeRegex.exec(content)) !== null) {
+        if (pm[1].toLowerCase().includes(shortName.toLowerCase())) {
+          // Find parent <type> to know the target
+          const beforePlugin = content.slice(0, pm.index);
+          const typeMatch = beforePlugin.match(/<type\s+name="([^"]+)"[^>]*>\s*$/m);
+          const target = typeMatch ? typeMatch[1] : 'unknown';
+          references.diXmlReferences.push({ type: 'registered-as-plugin', file: relPath, detail: `plugin on ${target} → ${pm[1]}` });
+        }
+      }
+      // Check if class appears as preference type
+      const prefRegex = /<preference\s+for="([^"]+)"\s+type="([^"]+)"\s*\/?>/g;
+      let prm;
+      while ((prm = prefRegex.exec(content)) !== null) {
+        if (prm[2].toLowerCase().includes(shortName.toLowerCase())) {
+          references.diXmlReferences.push({ type: 'registered-as-preference', file: relPath, detail: `preference for ${prm[1]} → ${prm[2]}` });
+        }
+      }
+    }
+  }
 
   // Check PHP files for direct references
   const escapedShort = shortName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -4016,11 +4043,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const reqStart = Date.now();
   logToFile('REQ', `${name}(${JSON.stringify(args || {})})`);
 
-  // ── Warmup guard: index compatibility check or serve process still loading ──
+  // ── Warmup guard: only block if no DB exists at all (nothing to search) ──
+  // Tools with filesystem fallback work without the serve process, so we
+  // don't block them during warmup. Only block if the DB doesn't exist.
   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_trace_data_flow', 'magento_find_event_dispatchers'];
+    'magento_trace_data_flow', 'magento_find_event_dispatchers',
+    // These tools have filesystem/di.xml fallbacks — work without serve process
+    'magento_find_class', 'magento_find_method', 'magento_find_plugin',
+    'magento_find_observer', 'magento_find_di_wiring', 'magento_module_structure',
+    'magento_batch', 'magento_find_config', 'magento_find_callers'];
   if (warmupInProgress && !indexFreeTools.includes(name)) {
     logToFile('REQ', `${name} → blocked (warmup: loading index)`);
     return {
@@ -5640,18 +5673,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const res = raw.map(normalizeResult).filter(r =>
                   r.magentoType === 'plugin' || r.path?.toLowerCase().includes('plugin')
                 );
-                text = formatSearchResults(res.slice(0, 5));
-                // DI registrations + method bodies (same as standalone find_plugin)
+                text = formatSearchResults(res.slice(0, 3));
+                // DI registrations + method bodies (compact: only targetMethod bodies)
                 if (a.targetClass) {
                   const diFiles = await getDiXmlFiles(config.magentoRoot);
                   const normalizedTarget = a.targetClass.replace(/\\\\/g, '\\');
                   const isFqcn = normalizedTarget.includes('\\');
                   const shortTarget = normalizedTarget.split('\\').pop().toLowerCase();
+                  let regCount = 0;
+                  text += '\n\n### DI Registrations\n';
                   for (const { content: diContent, relPath } of diFiles) {
+                    if (regCount >= 8) break;
                     if (!diContent.includes(isFqcn ? normalizedTarget : a.targetClass)) continue;
                     const typeBlockRegex = /<type\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/type>/g;
                     let tm;
                     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;
@@ -5659,22 +5696,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                       const pluginRegex = /<plugin\s+([^/>]*)\/?>/g;
                       let pm;
                       while ((pm = pluginRegex.exec(block)) !== null) {
+                        if (regCount >= 8) break;
                         const attrs = {};
                         const localAttrRe = /(\w+)="([^"]*)"/g;
-                        let am;
-                        while ((am = localAttrRe.exec(pm[1])) !== null) attrs[am[1]] = am[2];
-                        text += `\n- **${attrs.name || '?'}** → \`${attrs.type || '?'}\` (${relPath})`;
-                        if (attrs.type) {
+                        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 pFile = findClassFile(config.magentoRoot, attrs.type);
                           if (pFile) {
                             const methods = extractPluginMethods(pFile);
-                            for (const m of methods) {
+                            const relevant = methods.filter(m => m.targetMethod === a.targetMethod);
+                            for (const m of relevant) {
                               const body = readFullMethodBody(pFile, m.name);
-                              text += `\n  - \`${m.type}\` **${m.targetMethod}** → \`${m.name}()\``;
-                              if (body) text += '\n    ' + '```php\n    ' + body.split('\n').join('\n    ') + '\n    ' + '```';
+                              text += `  - \`${m.type}\` **${m.targetMethod}** → \`${m.name}()\`\n`;
+                              if (body) text += '    ' + '```php\n    ' + body.split('\n').join('\n    ') + '\n    ' + '```\n';
                             }
                           }
                         }
+                        regCount++;
                       }
                     }
                   }
@@ -5740,9 +5782,37 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 let res = raw.map(normalizeResult).filter(r =>
                   r.methodName?.toLowerCase() === ml || r.methods?.some(m => m.toLowerCase() === ml)
                 );
+                // Filesystem fallback: grep -rl for method signature
+                if (res.length === 0 && config.magentoRoot) {
+                  const methodSig = `function ${a.methodName}(`;
+                  const classShort = a.className ? a.className.split('\\').pop() : null;
+                  try {
+                    let files = [];
+                    if (classShort) {
+                      files = await glob(`**/${classShort}.php`, { cwd: config.magentoRoot, absolute: false, nodir: true });
+                    } else {
+                      const grepResult = execFileSync('grep', ['-rl', '--include=*.php', methodSig, '.'],
+                        { cwd: config.magentoRoot, encoding: 'utf-8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] });
+                      files = grepResult.trim().split('\n').filter(Boolean).map(f => f.replace(/^\.\//, ''));
+                    }
+                    for (const f of files.slice(0, 10)) {
+                      const absP = f.startsWith('/') ? f : path.join(config.magentoRoot, f);
+                      let content;
+                      try { content = readFileSync(absP, 'utf-8'); } catch { continue; }
+                      if (!content.includes(methodSig)) continue;
+                      let cn = null;
+                      const nsM = content.match(/namespace\s+([\w\\]+)/);
+                      const clM = content.match(/class\s+(\w+)/);
+                      if (nsM && clM) cn = nsM[1] + '\\' + clM[1];
+                      const body = readFullMethodBody(absP, a.methodName);
+                      res.push({ path: f, className: cn, methodName: a.methodName, score: 0.5, fullMethodBody: body || undefined });
+                      if (res.length >= 5) break;
+                    }
+                  } catch {}
+                }
                 for (const r of res.slice(0, 5)) {
-                  if (r.path?.endsWith('.php')) {
-                    const body = readFullMethodBody(r.path, a.methodName);
+                  if (r.path?.endsWith('.php') && !r.fullMethodBody) {
+                    const body = readFullMethodBody(path.join(config.magentoRoot, r.path), a.methodName);
                     if (body) r.fullMethodBody = body;
                   }
                 }
@@ -5752,13 +5822,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               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 mParts = a.moduleName.split('_');
+                // Hyphenate camelCase for vendor path: OrderSplit → order-split
+                const vendorPath = mParts.length === 2
+                  ? `module-${mParts[1].replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()}/`
+                  : '';
+                let 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));
                 });
+                // Filesystem fallback
+                if (res.length === 0 && config.magentoRoot && vendorPath) {
+                  try {
+                    const vendorGlob = `**/${vendorPath}**/*.{php,xml,phtml}`;
+                    const files = await glob(vendorGlob, { cwd: config.magentoRoot, absolute: false, nodir: true });
+                    for (const f of files.slice(0, 100)) {
+                      const entry = { path: f, score: 0.5 };
+                      if (f.includes('/Controller/')) entry.isController = true;
+                      if (f.includes('/Model/')) entry.isModel = true;
+                      if (f.includes('/Plugin/')) entry.isPlugin = true;
+                      if (f.includes('/Observer/')) entry.isObserver = true;
+                      if (f.endsWith('.xml')) entry.type = 'xml';
+                      const phpMatch = f.match(/\/([A-Z]\w+)\.php$/);
+                      if (phpMatch) entry.className = phpMatch[1];
+                      res.push(entry);
+                    }
+                  } catch {}
+                }
                 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)) {
@@ -5875,8 +5966,9 @@ async function main() {
       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
+      // Remove stale socket and lock so we don't connect to dead process
       try { if (existsSync(SOCK_PATH)) unlinkSync(SOCK_PATH); } catch {}
+      releasePrimaryLock();
     }
 
     const connected = await tryConnectSocket();
@@ -5887,47 +5979,53 @@ async function main() {
       role = 'primary';
       logToFile('INFO', 'Acquired primary lock — this instance owns the serve process');
 
-      // Check DB format (uses cache → instant if already validated)
-      if (existsSync(config.dbPath)) {
-        if (!(await checkDbFormat())) {
-          logToFile('WARN', 'Database format incompatible — scheduling background re-index');
-          startBackgroundReindex();
-        } else {
-          logToFile('INFO', 'Existing database is compatible — reusing index');
-        }
-      } else if (config.magentoRoot && existsSync(config.magentoRoot)) {
-        logToFile('INFO', 'No index database found — scheduling background index');
-        startBackgroundReindex();
-      }
-
-      const canStartServe = !reindexInProgress || (existsSync(config.dbPath) && (() => { try { return statSync(config.dbPath).size > 100; } catch { return false; } })());
-      if (canStartServe) {
+      // Start serve process in background — don't block tool availability
+      // Tools with filesystem fallbacks work immediately via execFileSync.
+      // Serve process provides faster search once ready.
+      (async () => {
         try {
-          startServeProcess();
-          if (serveReadyPromise) {
-            const ready = await Promise.race([
-              serveReadyPromise,
-              new Promise(r => setTimeout(() => r(false), 60000))
-            ]);
-            if (ready) {
-              logToFile('INFO', 'Serve process ready (primary)');
-              console.error('Serve process ready (primary)');
-              startSocketProxy();
+          // Check DB format (uses cache → instant if already validated)
+          if (existsSync(config.dbPath)) {
+            if (!(await checkDbFormat())) {
+              logToFile('WARN', 'Database format incompatible — scheduling background re-index');
+              startBackgroundReindex();
             } else {
-              logToFile('WARN', 'Serve process not ready in time, will use fallback');
-              console.error('Serve process not ready in time, will use fallback');
+              logToFile('INFO', 'Existing database is compatible — reusing index');
+            }
+          } else if (config.magentoRoot && existsSync(config.magentoRoot)) {
+            logToFile('INFO', 'No index database found — scheduling background index');
+            startBackgroundReindex();
+          }
+
+          const canStartServe = !reindexInProgress || (existsSync(config.dbPath) && (() => { try { return statSync(config.dbPath).size > 100; } catch { return false; } })());
+          if (canStartServe) {
+            startServeProcess();
+            if (serveReadyPromise) {
+              const ready = await Promise.race([
+                serveReadyPromise,
+                new Promise(r => setTimeout(() => r(false), 60000))
+              ]);
+              if (ready) {
+                logToFile('INFO', 'Serve process ready (primary)');
+                console.error('Serve process ready (primary)');
+                startSocketProxy();
+              } else {
+                logToFile('WARN', 'Serve process not ready in time, will use fallback');
+                console.error('Serve process not ready in time, will use fallback');
+              }
             }
           }
         } catch {
           // Non-fatal: falls back to execFileSync per query
         }
-      }
+      })();
     } else {
-      // Another instance is starting up — wait for its socket to appear
-      logToFile('INFO', 'Another instance is primary — waiting for socket...');
-      console.error('Waiting for primary instance to start serve process...');
-      for (let i = 0; i < 12; i++) { // wait up to 60s
-        await new Promise(r => setTimeout(r, 5000));
+      // Another instance is starting up — try socket briefly, then fall through
+      logToFile('INFO', 'Another instance is primary — trying socket...');
+      console.error('Trying to join existing serve process...');
+      // Quick check: 3 attempts at 2s intervals (6s max), then give up and use fallback
+      for (let i = 0; i < 3; i++) {
+        await new Promise(r => setTimeout(r, 2000));
         if (await tryConnectSocket()) {
           logToFile('INFO', 'Connected to socket after waiting (secondary)');
           console.error('Joined existing serve process (secondary)');
@@ -5935,15 +6033,21 @@ async function main() {
         }
       }
       if (!globalServeQuery) {
-        logToFile('WARN', 'Socket not available after waiting — using cold-start fallback');
+        logToFile('INFO', 'Socket not available — tools will use cold-start fallback');
       }
     }
 
-    await loadDescriptions();
-  } finally {
+    // Mark tools as available ASAP — filesystem fallbacks work without serve process
     warmupInProgress = false;
-    logToFile('INFO', 'Warmup complete — all tools available');
+    logToFile('INFO', 'Tools available (serve process loading in background)');
     console.error('Warmup complete — all tools available');
+
+    // Load descriptions in background (non-blocking)
+    loadDescriptions().catch(() => {});
+  } catch (err) {
+    warmupInProgress = false;
+    logToFile('WARN', `Startup error (tools still available via fallback): ${err.message}`);
+    console.error('Warmup complete — all tools available (with fallbacks)');
   }
 }