@mgamil/mapx 0.2.4

package/dist/frameworks/detectors/wordpress.js

@@ -0,0 +1,141 @@
+import { join, basename } from "node:path";
+import { existsSync } from "node:fs";
+class WordPressDetector {
+  name = "wordpress";
+  language = "php";
+  filePattern = /\.php$/;
+  // Standard WP template hierarchy files
+  static TEMPLATE_FILES = /* @__PURE__ */ new Set([
+    "front-page.php",
+    "home.php",
+    "single.php",
+    "page.php",
+    "archive.php",
+    "category.php",
+    "tag.php",
+    "taxonomy.php",
+    "search.php",
+    "404.php",
+    "index.php"
+  ]);
+  async detect(projectRoot, files) {
+    const wpConfig = join(projectRoot, "wp-config.php");
+    if (existsSync(wpConfig)) return true;
+    return files.some((f) => f.includes("wp-content/") || f.includes("wp-includes/"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    const fileName = basename(filePath);
+    if (WordPressDetector.TEMPLATE_FILES.has(fileName)) {
+      let pathVal = "/" + fileName.replace(/\.php$/, "");
+      if (fileName === "front-page.php") {
+        pathVal = "/";
+      }
+      routes.push({
+        framework: this.name,
+        method: "GET",
+        path: pathVal,
+        handlerFile: filePath,
+        handlerSymbol: fileName,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server",
+          templateFile: fileName
+        }
+      });
+    }
+    const restRegex = /register_rest_route\s*\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = restRegex.exec(content)) !== null) {
+      const namespace = match[1];
+      const routePath = match[2];
+      const fullPath = `/wp-json/${namespace.replace(/^\/|\/$/g, "")}/${routePath.replace(/^\/|\/$/g, "")}`;
+      const scanWindow = content.substring(match.index, match.index + 1e3);
+      const callbackMatch = scanWindow.match(/'callback'\s*=>\s*(?:['"]([^'"]+)['"]|\[\s*(?:['"]?([a-zA-Z0-9_]+)['"]?|([$]this))\s*,\s*['"]([^'"]+)['"]\s*\])/);
+      let handlerSymbol = "rest_callback";
+      if (callbackMatch) {
+        if (callbackMatch[1]) {
+          handlerSymbol = callbackMatch[1];
+        } else {
+          const className = callbackMatch[2] || "this";
+          const methodName = callbackMatch[4];
+          handlerSymbol = `${className}::${methodName}`;
+        }
+      }
+      let verbs = ["GET"];
+      const methodsMatch = scanWindow.match(/'methods'\s*=>\s*(?:['"]([^'"]+)['"]|WP_REST_Server::([A-Z_]+)|\[\s*([^\]]+)\s*\])/);
+      if (methodsMatch) {
+        if (methodsMatch[1]) {
+          verbs = [methodsMatch[1].toUpperCase()];
+        } else if (methodsMatch[2]) {
+          const constant = methodsMatch[2];
+          if (constant === "READABLE") verbs = ["GET"];
+          else if (constant === "CREATABLE") verbs = ["POST"];
+          else if (constant === "EDITABLE") verbs = ["PUT", "PATCH"];
+          else if (constant === "DELETABLE") verbs = ["DELETE"];
+          else verbs = ["ALL"];
+        } else if (methodsMatch[3]) {
+          verbs = methodsMatch[3].split(",").map((v) => v.trim().replace(/['"]/g, "").toUpperCase());
+        }
+      }
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(handlerSymbol.split("::")[0]);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      for (const verb of verbs) {
+        routes.push({
+          framework: this.name,
+          method: verb,
+          path: fullPath,
+          handlerFile: resolvedFile,
+          handlerSymbol,
+          metadata: {
+            confidence: "inferred",
+            routeType: "server"
+          }
+        });
+      }
+    }
+    return routes;
+  }
+  async extractHooks(filePath, content, ctx) {
+    const hooks = [];
+    const hookRegex = /\badd_(action|filter|shortcode)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(?:['"]([^'"]+)['"]|\[\s*(?:['"]?([a-zA-Z0-9_]+)['"]?|([$]this))\s*,\s*['"]([^'"]+)['"]\s*\])/g;
+    let match;
+    while ((match = hookRegex.exec(content)) !== null) {
+      const type = match[1];
+      const hookName = match[2];
+      let handlerSymbol = "callback";
+      if (match[3]) {
+        handlerSymbol = match[3];
+      } else {
+        const className = match[4] || "this";
+        const methodName = match[6];
+        handlerSymbol = `${className}::${methodName}`;
+      }
+      hooks.push({
+        framework: this.name,
+        hookName,
+        handlerFile: filePath,
+        handlerSymbol,
+        hookType: type === "shortcode" ? "shortcode" : type === "filter" ? "filter" : "action"
+      });
+    }
+    const ptRegex = /\bregister_post_type\s*\(\s*['"]([^'"]+)['"]/g;
+    while ((match = ptRegex.exec(content)) !== null) {
+      const postTypeName = match[1];
+      hooks.push({
+        framework: this.name,
+        hookName: postTypeName,
+        handlerFile: filePath,
+        handlerSymbol: "register_post_type",
+        hookType: "post_type"
+      });
+    }
+    return hooks;
+  }
+}
+export {
+  WordPressDetector
+};

package/dist/frameworks/detectors/yii.d.ts

@@ -0,0 +1,11 @@
+import { FrameworkDetector, ScanContext, RouteBinding } from '../../types.js';
+
+declare class YiiDetector implements FrameworkDetector {
+    readonly name = "yii";
+    readonly language = "php";
+    readonly filePattern: RegExp;
+    detect(projectRoot: string, files: string[]): Promise<boolean>;
+    extractRoutes(filePath: string, content: string, ctx: ScanContext): Promise<RouteBinding[]>;
+}
+
+export { YiiDetector };

package/dist/frameworks/detectors/yii.js

@@ -0,0 +1,131 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class YiiDetector {
+  name = "yii";
+  language = "php";
+  filePattern = /\.php$/;
+  async detect(projectRoot, files) {
+    const composerPath = join(projectRoot, "composer.json");
+    if (existsSync(composerPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(composerPath, "utf-8"));
+        const reqs = { ...pkg.require, ...pkg["require-dev"] };
+        if (reqs && (reqs["yiisoft/yii2"] || reqs["yiisoft/yii3"] || reqs["yiisoft/router"])) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return files.some((f) => f.includes("config/web.php") || f.includes("config/routes.php"));
+  }
+  async extractRoutes(filePath, content, ctx) {
+    const routes = [];
+    const yii2RuleRegex = /['"](?:(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)\s+)?([a-zA-Z0-9_.-]+)['"]\s*=>\s*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = yii2RuleRegex.exec(content)) !== null) {
+      const verb = match[1] || "GET";
+      const pathVal = "/" + match[2].replace(/^\/|\/$/g, "");
+      const target = match[3];
+      if (target.includes("/")) {
+        const parts = target.split("/");
+        const controller = parts[0];
+        const action = parts[1];
+        const controllerClassName = controller.charAt(0).toUpperCase() + controller.slice(1) + "Controller";
+        const actionMethodName = "action" + action.charAt(0).toUpperCase() + action.slice(1);
+        let resolvedFile = filePath;
+        const resolvedPath = ctx.resolveSymbolToFile(controllerClassName);
+        if (resolvedPath) {
+          resolvedFile = resolvedPath;
+        }
+        routes.push({
+          framework: this.name,
+          method: verb,
+          path: pathVal,
+          handlerFile: resolvedFile,
+          handlerSymbol: `${controllerClassName}::${actionMethodName}`,
+          metadata: {
+            confidence: "inferred",
+            routeType: "server"
+          }
+        });
+      }
+    }
+    if (content.includes("yii\\rest\\UrlRule")) {
+      const restControllerRegex = /'controller'\s*=>\s*(?:['"]([^'"]+)['"]|\[\s*([^\]]+)\s*\])/g;
+      while ((match = restControllerRegex.exec(content)) !== null) {
+        const controllers = [];
+        if (match[1]) {
+          controllers.push(match[1]);
+        } else if (match[2]) {
+          controllers.push(...match[2].split(",").map((c) => c.trim().replace(/['"]/g, "")));
+        }
+        for (const controller of controllers) {
+          const controllerClassName = controller.charAt(0).toUpperCase() + controller.slice(1) + "Controller";
+          const crudEndpoints = [
+            { verb: "GET", path: `/${controller}`, action: "actionIndex" },
+            { verb: "GET", path: `/${controller}/view`, action: "actionView" },
+            { verb: "POST", path: `/${controller}`, action: "actionCreate" },
+            { verb: "PUT", path: `/${controller}/update`, action: "actionUpdate" },
+            { verb: "PATCH", path: `/${controller}/update`, action: "actionUpdate" },
+            { verb: "DELETE", path: `/${controller}/delete`, action: "actionDelete" },
+            { verb: "OPTIONS", path: `/${controller}`, action: "actionOptions" }
+          ];
+          let resolvedFile = filePath;
+          const resolvedPath = ctx.resolveSymbolToFile(controllerClassName);
+          if (resolvedPath) {
+            resolvedFile = resolvedPath;
+          }
+          for (const ep of crudEndpoints) {
+            routes.push({
+              framework: this.name,
+              method: ep.verb,
+              path: ep.path,
+              handlerFile: resolvedFile,
+              handlerSymbol: `${controllerClassName}::${ep.action}`,
+              metadata: {
+                confidence: "inferred",
+                routeType: "server"
+              }
+            });
+          }
+        }
+      }
+    }
+    let yii3GroupPrefix = "";
+    const groupMatch = content.match(/Route::addGroup\s*\(\s*['"]([^'"]+)['"]/);
+    if (groupMatch) {
+      yii3GroupPrefix = groupMatch[1];
+    }
+    const yii3RouteRegex = /Route::(get|post|put|delete|patch|options|head)\s*\(\s*['"]([^'"]+)['"]\s*\)\s*(?:->[a-zA-Z0-9_]+\s*\([^)]*\)\s*)*->action\s*\(\s*(?:\[\s*([a-zA-Z0-9_]+)::class\s*,\s*['"]([^'"]+)['"]\s*\]|['"]([^'"]+)['"])/g;
+    while ((match = yii3RouteRegex.exec(content)) !== null) {
+      const verb = match[1].toUpperCase();
+      const pathVal = match[2];
+      const controllerClass = match[3] || "Controller";
+      const actionMethod = match[4] || match[5] || "index";
+      const cleanGroup = yii3GroupPrefix.replace(/^\/|\/$/g, "");
+      const cleanPath = pathVal.replace(/^\/|\/$/g, "");
+      const combinedPath = "/" + [cleanGroup, cleanPath].filter(Boolean).join("/");
+      let resolvedFile = filePath;
+      const resolvedPath = ctx.resolveSymbolToFile(controllerClass);
+      if (resolvedPath) {
+        resolvedFile = resolvedPath;
+      }
+      routes.push({
+        framework: this.name,
+        method: verb,
+        path: combinedPath,
+        handlerFile: resolvedFile,
+        handlerSymbol: `${controllerClass}::${actionMethod}`,
+        metadata: {
+          confidence: "inferred",
+          routeType: "server"
+        }
+      });
+    }
+    return routes;
+  }
+}
+export {
+  YiiDetector
+};

package/dist/frameworks/framework-registry.d.ts

@@ -0,0 +1,13 @@
+import { FrameworkDetector } from '../types.js';
+
+declare class FrameworkRegistry {
+    private static instance;
+    private detectors;
+    private constructor();
+    static getInstance(): FrameworkRegistry;
+    register(detector: FrameworkDetector): void;
+    getDetectors(): FrameworkDetector[];
+    detectActiveFrameworks(projectRoot: string, files: string[]): Promise<FrameworkDetector[]>;
+}
+
+export { FrameworkRegistry };

package/dist/frameworks/framework-registry.js

@@ -0,0 +1,77 @@
+import { LaravelDetector } from "./detectors/laravel.js";
+import { DjangoDetector } from "./detectors/django.js";
+import { FlaskDetector } from "./detectors/flask.js";
+import { FastAPIDetector } from "./detectors/fastapi.js";
+import { ExpressDetector } from "./detectors/express.js";
+import { NestJSDetector } from "./detectors/nestjs.js";
+import { ReactRouterDetector } from "./detectors/react-router.js";
+import { TanstackRouterDetector } from "./detectors/tanstack-router.js";
+import { NextJSDetector } from "./detectors/nextjs.js";
+import { SvelteKitDetector } from "./detectors/sveltekit.js";
+import { VueRouterDetector } from "./detectors/vue-router.js";
+import { DrupalDetector } from "./detectors/drupal.js";
+import { RailsDetector } from "./detectors/rails.js";
+import { SpringDetector } from "./detectors/spring.js";
+import { GoDetector } from "./detectors/go.js";
+import { RustDetector } from "./detectors/rust.js";
+import { AspNetDetector } from "./detectors/aspnet.js";
+import { VaporDetector } from "./detectors/vapor.js";
+import { SymfonyDetector } from "./detectors/symfony.js";
+import { YiiDetector } from "./detectors/yii.js";
+import { WordPressDetector } from "./detectors/wordpress.js";
+class FrameworkRegistry {
+  static instance = null;
+  detectors = [];
+  constructor() {
+    this.register(new LaravelDetector());
+    this.register(new DjangoDetector());
+    this.register(new FlaskDetector());
+    this.register(new FastAPIDetector());
+    this.register(new ExpressDetector());
+    this.register(new NestJSDetector());
+    this.register(new ReactRouterDetector());
+    this.register(new TanstackRouterDetector());
+    this.register(new NextJSDetector());
+    this.register(new SvelteKitDetector());
+    this.register(new VueRouterDetector());
+    this.register(new DrupalDetector());
+    this.register(new RailsDetector());
+    this.register(new SpringDetector());
+    this.register(new GoDetector());
+    this.register(new RustDetector());
+    this.register(new AspNetDetector());
+    this.register(new VaporDetector());
+    this.register(new SymfonyDetector());
+    this.register(new YiiDetector());
+    this.register(new WordPressDetector());
+  }
+  static getInstance() {
+    if (!FrameworkRegistry.instance) {
+      FrameworkRegistry.instance = new FrameworkRegistry();
+    }
+    return FrameworkRegistry.instance;
+  }
+  register(detector) {
+    this.detectors.push(detector);
+  }
+  getDetectors() {
+    return this.detectors;
+  }
+  async detectActiveFrameworks(projectRoot, files) {
+    const active = [];
+    for (const detector of this.detectors) {
+      try {
+        const isDetected = await detector.detect(projectRoot, files);
+        if (isDetected) {
+          active.push(detector);
+        }
+      } catch (err) {
+        console.error(`Error detecting framework ${detector.name}:`, err);
+      }
+    }
+    return active;
+  }
+}
+export {
+  FrameworkRegistry
+};

package/dist/frameworks/route-registry.d.ts

@@ -0,0 +1,26 @@
+import { RouteBinding, HookBinding } from '../types.js';
+
+declare class RouteRegistry {
+    private routes;
+    private hooks;
+    getRoutes(): RouteBinding[];
+    getHooks(): HookBinding[];
+    addRoute(route: RouteBinding): void;
+    addHook(hook: HookBinding): void;
+    clear(): void;
+    clearRepo(repoName: string, filePaths?: Set<string>): void;
+    load(workspaceRoot: string): Promise<void>;
+    save(workspaceRoot: string): Promise<void>;
+    queryRoutes(filters: {
+        framework?: string;
+        method?: string;
+        path?: string;
+    }): RouteBinding[];
+    queryHooks(filters: {
+        framework?: string;
+        hookType?: string;
+        hookName?: string;
+    }): HookBinding[];
+}
+
+export { RouteRegistry };

package/dist/frameworks/route-registry.js

@@ -0,0 +1,102 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+class RouteRegistry {
+  routes = [];
+  hooks = [];
+  getRoutes() {
+    return this.routes;
+  }
+  getHooks() {
+    return this.hooks;
+  }
+  addRoute(route) {
+    this.routes.push(route);
+  }
+  addHook(hook) {
+    this.hooks.push(hook);
+  }
+  clear() {
+    this.routes = [];
+    this.hooks = [];
+  }
+  clearRepo(repoName, filePaths) {
+    this.routes = this.routes.filter((r) => {
+      if (r.metadata && r.metadata.repo === repoName) return false;
+      if (filePaths) {
+        if (filePaths.has(r.handlerFile)) return false;
+        if (r.metadata && r.metadata.sourceFile && filePaths.has(r.metadata.sourceFile)) return false;
+      }
+      return true;
+    });
+    this.hooks = this.hooks.filter((h) => {
+      if (h.metadata && h.metadata.repo === repoName) return false;
+      if (filePaths) {
+        if (filePaths.has(h.handlerFile)) return false;
+        if (h.metadata && h.metadata.sourceFile && filePaths.has(h.metadata.sourceFile)) return false;
+      }
+      return true;
+    });
+  }
+  async load(workspaceRoot) {
+    const routesPath = join(workspaceRoot, ".mapx", "routes.json");
+    if (existsSync(routesPath)) {
+      try {
+        const content = await readFile(routesPath, "utf-8");
+        this.routes = JSON.parse(content);
+      } catch {
+        this.routes = [];
+      }
+    }
+    const hooksPath = join(workspaceRoot, ".mapx", "hooks.json");
+    if (existsSync(hooksPath)) {
+      try {
+        const content = await readFile(hooksPath, "utf-8");
+        this.hooks = JSON.parse(content);
+      } catch {
+        this.hooks = [];
+      }
+    }
+  }
+  async save(workspaceRoot) {
+    const routesPath = join(workspaceRoot, ".mapx", "routes.json");
+    const hooksPath = join(workspaceRoot, ".mapx", "hooks.json");
+    try {
+      await writeFile(routesPath, JSON.stringify(this.routes, null, 2), "utf-8");
+      await writeFile(hooksPath, JSON.stringify(this.hooks, null, 2), "utf-8");
+    } catch (err) {
+      console.error("Failed to save route/hook registry:", err);
+    }
+  }
+  queryRoutes(filters) {
+    return this.routes.filter((r) => {
+      if (filters.framework && r.framework.toLowerCase() !== filters.framework.toLowerCase()) {
+        return false;
+      }
+      if (filters.method && r.method.toUpperCase() !== filters.method.toUpperCase()) {
+        return false;
+      }
+      if (filters.path && !r.path.toLowerCase().includes(filters.path.toLowerCase())) {
+        return false;
+      }
+      return true;
+    });
+  }
+  queryHooks(filters) {
+    return this.hooks.filter((h) => {
+      if (filters.framework && h.framework.toLowerCase() !== filters.framework.toLowerCase()) {
+        return false;
+      }
+      if (filters.hookType && h.hookType.toLowerCase() !== filters.hookType.toLowerCase()) {
+        return false;
+      }
+      if (filters.hookName && !h.hookName.toLowerCase().includes(filters.hookName.toLowerCase())) {
+        return false;
+      }
+      return true;
+    });
+  }
+}
+export {
+  RouteRegistry
+};

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { buildCLI } from './cli.js';
+export { startMcpServer } from './mcp.js';
+export { Store } from './core/store.js';
+export { MapxGraph } from './core/graph.js';
+export { Scanner } from './core/scanner.js';
+export { Config } from './core/config.js';
+export { LLMExporter } from './exporters/llm-exporter.js';
+export { GraphExporter } from './exporters/graph-exporter.js';
+export { DotExporter } from './exporters/dot-exporter.js';
+export { FlowTracer } from './core/flow-tracer.js';
+export { AgentGenerator } from './agents/generator.js';
+export { WorkspaceManager } from './core/workspace-manager.js';
+export { ContextBuilder, ContextOptions, ContextResult } from './core/context-builder.js';
+import 'commander';
+import '@modelcontextprotocol/sdk/server/index.js';
+import './core/store-interface.js';
+import './types.js';
+import './languages/registry.js';
+import './agents/templates.js';

package/dist/index.js

@@ -0,0 +1,30 @@
+import { buildCLI } from "./cli.js";
+import { startMcpServer } from "./mcp.js";
+import { Store } from "./core/store.js";
+import { MapxGraph } from "./core/graph.js";
+import { Scanner } from "./core/scanner.js";
+import { Config } from "./core/config.js";
+import { LLMExporter } from "./exporters/llm-exporter.js";
+import { GraphExporter } from "./exporters/graph-exporter.js";
+import { DotExporter } from "./exporters/dot-exporter.js";
+import { FlowTracer } from "./core/flow-tracer.js";
+import { AgentGenerator } from "./agents/generator.js";
+import { WorkspaceManager } from "./core/workspace-manager.js";
+import { ContextBuilder, ContextOptions, ContextResult } from "./core/context-builder.js";
+export {
+  AgentGenerator,
+  Config,
+  ContextBuilder,
+  ContextOptions,
+  ContextResult,
+  DotExporter,
+  FlowTracer,
+  GraphExporter,
+  LLMExporter,
+  MapxGraph,
+  Scanner,
+  Store,
+  WorkspaceManager,
+  buildCLI,
+  startMcpServer
+};

package/dist/languages/index.d.ts

@@ -0,0 +1,2 @@
+export { LanguageDefinition, getBuiltinLanguages, getLanguageForFile, getLanguageNames, isBuiltInLanguage } from './registry.js';
+import '../types.js';

package/dist/languages/index.js

@@ -0,0 +1,7 @@
+import { getBuiltinLanguages, getLanguageForFile, getLanguageNames, isBuiltInLanguage } from "./registry.js";
+export {
+  getBuiltinLanguages,
+  getLanguageForFile,
+  getLanguageNames,
+  isBuiltInLanguage
+};

package/dist/languages/installer.d.ts

@@ -0,0 +1,13 @@
+declare const GRAMMARS_DIR: string;
+declare const QUERIES_DIR: string;
+interface InstallableLanguageInfo {
+    name: string;
+    package: string;
+    file: string;
+}
+declare const INSTALLABLE_LANGUAGES: Record<string, InstallableLanguageInfo>;
+declare function isLanguageInstalled(name: string): boolean;
+declare function installLanguage(name: string): Promise<void>;
+declare function uninstallLanguage(name: string): Promise<void>;
+
+export { GRAMMARS_DIR, INSTALLABLE_LANGUAGES, type InstallableLanguageInfo, QUERIES_DIR, installLanguage, isLanguageInstalled, uninstallLanguage };