magector 2.6.0 → 2.6.2

package/package.json

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

package/src/cli.js

@@ -12,6 +12,8 @@ import { resolveBinary } from './binary.js';
 import { ensureModels, resolveModels } from './model.js';
 import { init, setup } from './init.js';
 import { checkForUpdate } from './update.js';
+import { createRequire } from 'module';
+const __cliPkg = createRequire(import.meta.url)('../package.json');
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -327,6 +329,12 @@ async function main() {
       await import('./validation/benchmark.js');
       break;
 
+    case 'version':
+    case '--version':
+    case '-V':
+      console.log(`magector v${__cliPkg.version}`);
+      break;
+
     case 'help':
     case '--help':
     case '-h':

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 [];
@@ -2261,7 +2279,20 @@ async function analyzeImpact(className) {
   // Use vector search to find candidate files (much faster than globbing all PHP)
   const rawSearch = await rustSearchAsync(`${shortName} ${className}`, 50).catch(() => []);
   const raw = Array.isArray(rawSearch) ? rawSearch : [];
-  const relatedPaths = raw.map(r => normalizeResult(r)).filter(r => r.path);
+  let relatedPaths = raw.map(r => normalizeResult(r)).filter(r => r.path);
+
+  // Filesystem fallback: if vector search found too few files, find the class file via glob
+  if (relatedPaths.length < 5 && root) {
+    try {
+      const classFiles = await glob(`**/${shortName}.php`, { cwd: root, absolute: false, nodir: true });
+      const existingPaths = new Set(relatedPaths.map(r => r.path));
+      for (const f of classFiles) {
+        if (!existingPaths.has(f)) {
+          relatedPaths.push({ path: f, className: shortName, score: 0.3 });
+        }
+      }
+    } catch {}
+  }
 
   // Check DI references via xml parsing
   const diTrace = await traceDependency(className, 'both');
@@ -4057,10 +4088,49 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const query = `${args.className} ${ns}`.trim();
         const raw = await rustSearchAsync(query, 30);
         const classLower = args.className.toLowerCase();
-        const results = raw.map(normalizeResult).filter(r =>
+        let results = raw.map(normalizeResult).filter(r =>
           r.className?.toLowerCase().includes(classLower) ||
           r.path?.toLowerCase().includes(classLower.replace(/\\/g, '/'))
         );
+
+        // Filesystem fallback: if vector search found nothing, glob for ClassName.php
+        if (results.length === 0 && config.magentoRoot) {
+          const shortName = args.className.split('\\').pop();
+          const globPattern = `**/${shortName}.php`;
+          try {
+            const files = await glob(globPattern, { cwd: config.magentoRoot, absolute: false, nodir: true, ignore: ['**/test/**', '**/tests/**', '**/Test/**'] });
+            // Filter by namespace if provided
+            const nsLower = ns.toLowerCase().replace(/\\\\/g, '/').replace(/\\/g, '/');
+            const matched = files.filter(f => {
+              if (!nsLower) return true;
+              return f.toLowerCase().includes(nsLower);
+            }).slice(0, 10);
+            // Build result entries from file paths
+            for (const filePath of matched) {
+              const absPath = path.join(config.magentoRoot, filePath);
+              let className = shortName;
+              try {
+                const content = readFileSync(absPath, 'utf-8');
+                const nsMatch = content.match(/namespace\s+([\w\\]+)/);
+                if (nsMatch) className = nsMatch[1] + '\\' + shortName;
+                const methodsFound = [];
+                const methodRegex = /public\s+function\s+(\w+)\s*\(/g;
+                let mm;
+                while ((mm = methodRegex.exec(content)) !== null) methodsFound.push(mm[1]);
+                results.push({
+                  path: filePath,
+                  className,
+                  methods: methodsFound,
+                  score: 0.5,
+                  searchText: content.slice(0, 300)
+                });
+              } catch {
+                results.push({ path: filePath, className, score: 0.5 });
+              }
+            }
+          } catch {}
+        }
+
         return {
           content: [{
             type: 'text',
@@ -4209,14 +4279,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           const diFiles = await getDiXmlFiles(fpRoot);
           // Normalize target class for matching (both \ and \\)
           const normalizedTarget = args.targetClass.replace(/\\\\/g, '\\');
+          const isFqcn = normalizedTarget.includes('\\');
+          const shortTarget = normalizedTarget.split('\\').pop().toLowerCase();
           for (const { content, relPath } of diFiles) {
-            if (!content.includes(normalizedTarget)) continue;
+            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;
@@ -4288,19 +4364,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': {
@@ -4592,18 +4684,40 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // Support both app/code (Magento/Catalog/) and vendor (module-catalog/) paths
         const modulePath = args.moduleName.replace('_', '/') + '/';
         const parts = args.moduleName.split('_');
+        // Hyphenate camelCase for vendor path: OrderSplit → order-split
         const vendorPath = parts.length === 2
-          ? `module-${parts[1].toLowerCase()}/`
+          ? `module-${parts[1].replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()}/`
           : '';
-        const results = raw.map(normalizeResult).filter(r => {
-          const path = r.path || '';
+        let results = raw.map(normalizeResult).filter(r => {
+          const p = r.path || '';
           const mod = r.module || '';
           // Exact module match or directory-level path match (trailing slash prevents Catalog matching CatalogRule)
           return mod === args.moduleName ||
-            path.includes(modulePath) ||
-            (vendorPath && path.toLowerCase().includes(vendorPath));
+            p.includes(modulePath) ||
+            (vendorPath && p.toLowerCase().includes(vendorPath));
         });
 
+        // Filesystem fallback: if vector search found nothing, glob the module directory
+        if (results.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('/Block/')) entry.isBlock = true;
+              if (f.includes('/Plugin/')) entry.isPlugin = true;
+              if (f.includes('/Observer/')) entry.isObserver = true;
+              if (f.endsWith('.xml')) entry.type = 'xml';
+              // Extract class name from path
+              const phpMatch = f.match(/\/([A-Z]\w+)\.php$/);
+              if (phpMatch) entry.className = phpMatch[1];
+              results.push(entry);
+            }
+          } catch {}
+        }
+
         const structure = {
           controllers: results.filter(r => r.isController || r.path?.includes('/Controller/')),
           models: results.filter(r => r.isModel || (r.path?.includes('/Model/') && !r.path?.includes('ResourceModel'))),
@@ -5450,9 +5564,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const qr = `${a.className} ${ns}`.trim();
                 const raw = await rustSearchAsync(qr, 30);
                 const cl = a.className.toLowerCase();
-                const res = raw.map(normalizeResult).filter(r =>
+                let res = raw.map(normalizeResult).filter(r =>
                   r.className?.toLowerCase().includes(cl) || r.path?.toLowerCase().includes(cl.replace(/\\/g, '/'))
                 );
+                // Filesystem fallback for batch find_class
+                if (res.length === 0 && config.magentoRoot) {
+                  const shortName = a.className.split('\\').pop();
+                  try {
+                    const files = await glob(`**/${shortName}.php`, { cwd: config.magentoRoot, absolute: false, nodir: true });
+                    for (const f of files.slice(0, 5)) {
+                      res.push({ path: f, className: shortName, score: 0.5 });
+                    }
+                  } catch {}
+                }
                 text = formatSearchResults(res.slice(0, 5));
                 break;
               }
@@ -5533,6 +5657,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}`;
             }
@@ -5625,6 +5777,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)');