@mgamil/mapx 0.2.4

package/dist/ui-server.js

@@ -0,0 +1,504 @@
+import { createServer } from "node:http";
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { resolve, join, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Config } from "./core/config.js";
+import { Store } from "./core/store.js";
+import { MapxGraph } from "./core/graph.js";
+import { calculateMetrics, calculateGraphMetrics } from "./core/metrics.js";
+import { ContextBuilder } from "./core/context-builder.js";
+import { RouteRegistry } from "./frameworks/route-registry.js";
+import { UiEventBus, getToolCallsLogPath } from "./ui-events.js";
+import { getChangedFiles, isGitRepo } from "./core/git-tracker.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = resolve(__filename, "..");
+function findUiDir() {
+  if (existsSync(__filename)) {
+    const root = resolve(__dirname, "..");
+    if (existsSync(join(root, "dist/ui/main.js"))) {
+      return join(root, "dist/ui");
+    }
+    if (existsSync(join(root, "ui/main.js"))) {
+      return join(root, "ui");
+    }
+  }
+  const binDir = resolve(process.execPath, "..");
+  const candidates = [
+    join(binDir, "ui"),
+    // next to binary
+    resolve(binDir, "..", "share", "mapx", "ui"),
+    // XDG system
+    join(process.env["HOME"] ?? "", ".local", "share", "mapx", "ui")
+    // XDG user
+  ];
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "main.js"))) {
+      return dir;
+    }
+  }
+  return join(__dirname, "ui");
+}
+function startUiServer(opts) {
+  const { port, host, token, dir } = opts;
+  const uiDir = findUiDir();
+  const rateLimitMap = /* @__PURE__ */ new Map();
+  const isRateLimited = (ip) => {
+    const now = Date.now();
+    const windowStart = now - 6e4;
+    let timestamps = rateLimitMap.get(ip) || [];
+    timestamps = timestamps.filter((t) => t > windowStart);
+    if (timestamps.length >= 10) {
+      return true;
+    }
+    timestamps.push(now);
+    rateLimitMap.set(ip, timestamps);
+    return false;
+  };
+  const getClientIp = (req) => {
+    return req.headers["x-forwarded-for"] || req.socket.remoteAddress || "unknown";
+  };
+  const checkAuth = (req) => {
+    if (!token) return true;
+    const auth = req.headers["authorization"] || req.headers["Authorization"];
+    if (typeof auth !== "string") return false;
+    return auth.trim() === `Bearer ${token}`;
+  };
+  const setCorsHeaders = (req, res) => {
+    const origin = req.headers.origin;
+    if (origin && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+    } else {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
+  };
+  const server = createServer(async (req, res) => {
+    setCorsHeaders(req, res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const ip = getClientIp(req);
+    const parsedUrl = new URL(req.url || "/", `http://${host}:${port}`);
+    const pathname = parsedUrl.pathname;
+    if (pathname.startsWith("/api") || pathname === "/events") {
+      if (!checkAuth(req)) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized: invalid or missing Bearer token" }));
+        return;
+      }
+    }
+    if (pathname === "/api/context" || pathname === "/api/graph") {
+      if (isRateLimited(ip)) {
+        res.writeHead(429, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Rate limit exceeded: max 10 requests per minute" }));
+        return;
+      }
+    }
+    try {
+      if (pathname === "/api/status") {
+        const configPath = resolve(dir, ".mapx", "config.json");
+        if (!existsSync(configPath)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Mapx not initialized" }));
+          return;
+        }
+        const dbPath = resolve(dir, ".mapx", "mapx.db");
+        const store = new Store(dbPath);
+        try {
+          const fileCount = store.getFileCount();
+          const symbolCount = store.getSymbolCount();
+          const edgeCount = store.getEdgeCount();
+          const lastScan = store.getMeta("last_scan_time") || "never";
+          const config = await Config.load(dir);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            repoName: config.repo.name,
+            lastScan,
+            fileCount,
+            symbolCount,
+            edgeCount,
+            languages: store.getLanguageBreakdown()
+          }));
+        } finally {
+          store.close();
+        }
+        return;
+      }
+      if (pathname === "/api/graph") {
+        const dbPath = resolve(dir, ".mapx", "mapx.db");
+        const store = new Store(dbPath);
+        try {
+          const files = store.getAllFiles();
+          const edges = store.getAllEdges();
+          const elements = [];
+          for (const f of files) {
+            const fPath = f.path;
+            elements.push({
+              data: {
+                id: fPath,
+                label: fPath.split("/").pop() || fPath,
+                type: "file",
+                language: f.language,
+                size: f.size_bytes,
+                lines: f.lines
+              }
+            });
+          }
+          for (const e of edges) {
+            elements.push({
+              data: {
+                id: `edge-${e.source_file}-${e.target_file}`,
+                source: e.source_file,
+                target: e.target_file,
+                type: e.edge_type,
+                verifiability: e.verifiability
+              }
+            });
+          }
+          const payload = JSON.stringify(elements);
+          if (payload.length > 10 * 1024 * 1024) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Graph too large (exceeded 10MB limit)" }));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(payload);
+        } finally {
+          store.close();
+        }
+        return;
+      }
+      if (pathname === "/api/symbols") {
+        const dbPath = resolve(dir, ".mapx", "mapx.db");
+        const store = new Store(dbPath);
+        try {
+          const term = parsedUrl.searchParams.get("q") || "";
+          const limit = parseInt(parsedUrl.searchParams.get("limit") || "100", 10);
+          const results = store.searchSymbolsFiltered({ term, limit });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(results));
+        } finally {
+          store.close();
+        }
+        return;
+      }
+      if (pathname.startsWith("/api/symbol/")) {
+        const dbPath = resolve(dir, ".mapx", "mapx.db");
+        const store = new Store(dbPath);
+        try {
+          const symName = decodeURIComponent(pathname.substring("/api/symbol/".length));
+          const sym = store.getSymbolByName(symName);
+          if (!sym) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Symbol not found" }));
+            return;
+          }
+          const callers = store.getCallersOfSymbol(symName);
+          const callees = store.getCalleesOfSymbol(symName);
+          let sourceCode = "";
+          if (sym.file_path) {
+            try {
+              const fullFilePath = resolve(dir, sym.file_path);
+              if (existsSync(fullFilePath)) {
+                const fileContent = readFileSync(fullFilePath, "utf-8");
+                const lines = fileContent.split("\n");
+                const start = Math.max(0, (sym.start_line || 1) - 1);
+                const end = Math.min(lines.length, sym.end_line || lines.length);
+                sourceCode = lines.slice(start, end).join("\n");
+              }
+            } catch {
+            }
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            symbol: sym,
+            callers,
+            callees,
+            sourceCode
+          }));
+        } finally {
+          store.close();
+        }
+        return;
+      }
+      if (pathname === "/api/metrics") {
+        const dbPath = resolve(dir, ".mapx", "mapx.db");
+        const store = new Store(dbPath);
+        try {
+          const config = await Config.load(dir);
+          const graph = new MapxGraph(config.repo.name);
+          for (const file of store.getAllFiles()) {
+            graph.addFileNode(file.path, file.language, file.size_bytes, file.lines);
+          }
+          for (const sym of store.getAllSymbols()) {
+            graph.addSymbolNode(sym.name, sym.file_path, sym.name, sym.kind, sym.start_line, sym.end_line, sym.scope);
+          }
+          for (const edge of store.getAllEdges()) {
+            graph.addDependencyEdge({
+              sourceFile: edge.source_file,
+              targetFile: edge.target_file,
+              sourceSymbol: edge.source_symbol,
+              targetSymbol: edge.target_symbol,
+              edgeType: edge.edge_type,
+              repo: edge.repo,
+              weight: edge.weight,
+              verifiability: edge.verifiability,
+              targetRepo: edge.target_repo
+            });
+          }
+          const fileCount = store.getFileCount();
+          const symbolCount = store.getSymbolCount();
+          const edgeCount = store.getEdgeCount();
+          const fileMetrics = calculateMetrics(store, { repo: config.repo.name });
+          const graphMetrics = calculateGraphMetrics(store, config.repo.name);
+          const topFiles = store.getTopFilesByPageRank(graph, 10);
+          const topSymbols = store.getTopSymbolsByPageRank(graph, 10);
+          const verifiedEdges = store.raw.prepare("SELECT COUNT(*) as cnt FROM edges WHERE verifiability = 'verified'").get()?.cnt || 0;
+          const inferredEdges = store.raw.prepare("SELECT COUNT(*) as cnt FROM edges WHERE verifiability = 'inferred'").get()?.cnt || 0;
+          const languages = store.getLanguageBreakdown();
+          const symbolKinds = store.raw.prepare(
+            "SELECT kind, COUNT(*) as cnt FROM symbols GROUP BY kind ORDER BY cnt DESC"
+          ).all();
+          const edgeTypes = store.raw.prepare(
+            "SELECT edge_type, COUNT(*) as cnt FROM edges GROUP BY edge_type ORDER BY cnt DESC"
+          ).all();
+          let dbSize = 0;
+          try {
+            dbSize = statSync(dbPath).size;
+          } catch {
+          }
+          const repoRoot = resolve(dir, config.repo.path);
+          const isGit = isGitRepo(repoRoot);
+          const lastCommit = store.getMeta("last_scan_commit:" + config.repo.name) || store.getMeta("last_scan_commit");
+          const gitChanges = isGit ? getChangedFiles(repoRoot, lastCommit || void 0) : [];
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            totalFiles: fileCount,
+            totalSymbols: symbolCount,
+            totalEdges: edgeCount,
+            verifiedEdges,
+            inferredEdges,
+            languages,
+            symbolKinds,
+            edgeTypes,
+            avgEdgesPerFile: fileCount > 0 ? (edgeCount / fileCount).toFixed(2) : "0",
+            dbSize,
+            density: `${(graphMetrics.density * 100).toFixed(4)}%`,
+            transitivity: graphMetrics.transitivity.toFixed(4),
+            git: {
+              isGit,
+              changesCount: gitChanges.length,
+              changes: gitChanges
+            },
+            fileMetrics,
+            topFiles,
+            topSymbols
+          }));
+        } finally {
+          store.close();
+        }
+        return;
+      }
+      if (pathname === "/api/context") {
+        if (req.method !== "POST") {
+          res.writeHead(405, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Method not allowed" }));
+          return;
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk;
+        });
+        req.on("end", async () => {
+          let store = null;
+          try {
+            const data = JSON.parse(body);
+            const task = data.task || "";
+            const dbPath = resolve(dir, ".mapx", "mapx.db");
+            store = new Store(dbPath);
+            const config = await Config.load(dir);
+            const graph = new MapxGraph(config.repo.name);
+            for (const file of store.getAllFiles()) {
+              graph.addFileNode(file.path, file.language, file.size_bytes, file.lines);
+            }
+            for (const sym of store.getAllSymbols()) {
+              graph.addSymbolNode(sym.name, sym.file_path, sym.name, sym.kind, sym.start_line, sym.end_line, sym.scope);
+            }
+            for (const edge of store.getAllEdges()) {
+              graph.addDependencyEdge({
+                sourceFile: edge.source_file,
+                targetFile: edge.target_file,
+                sourceSymbol: edge.source_symbol,
+                targetSymbol: edge.target_symbol,
+                edgeType: edge.edge_type,
+                repo: edge.repo,
+                weight: edge.weight,
+                verifiability: edge.verifiability,
+                targetRepo: edge.target_repo
+              });
+            }
+            const builder = new ContextBuilder(store, graph);
+            const context = await builder.buildContext({ task, tokens: 15e3 });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(context));
+          } catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: err.message }));
+          } finally {
+            if (store) {
+              store.close();
+            }
+          }
+        });
+        return;
+      }
+      if (pathname === "/api/routes") {
+        const routeRegistry = new RouteRegistry();
+        await routeRegistry.load(dir);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          routes: routeRegistry.getRoutes(),
+          hooks: routeRegistry.getHooks()
+        }));
+        return;
+      }
+      if (pathname === "/api/tool-calls") {
+        const mapxDir = resolve(dir, ".mapx");
+        const logPath = getToolCallsLogPath(mapxDir);
+        const events = [];
+        if (existsSync(logPath)) {
+          try {
+            const content = readFileSync(logPath, "utf-8");
+            const lines = content.split("\n").filter(Boolean);
+            const recent = lines.slice(-100).reverse();
+            for (const line of recent) {
+              try {
+                events.push(JSON.parse(line));
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(events));
+        return;
+      }
+      if (pathname === "/events") {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive"
+        });
+        const eventBus = UiEventBus.getInstance();
+        const sendEvent = (name, data) => {
+          res.write(`event: ${name}
+data: ${JSON.stringify(data)}
+
+`);
+        };
+        const onToolCall = (event) => sendEvent("tool-call", event);
+        const onScanProgress = (event) => sendEvent("scan-progress", event);
+        const onScanComplete = (event) => sendEvent("scan-complete", event);
+        eventBus.on("tool-call", onToolCall);
+        eventBus.on("scan-progress", onScanProgress);
+        eventBus.on("scan-complete", onScanComplete);
+        const mapxDir = resolve(dir, ".mapx");
+        const logPath = getToolCallsLogPath(mapxDir);
+        let lastSize = 0;
+        try {
+          lastSize = existsSync(logPath) ? statSync(logPath).size : 0;
+        } catch {
+        }
+        const pollLogFile = () => {
+          try {
+            if (!existsSync(logPath)) return;
+            const currentSize = statSync(logPath).size;
+            if (currentSize <= lastSize) {
+              if (currentSize < lastSize) lastSize = currentSize;
+              return;
+            }
+            const { openSync, readSync, closeSync } = require("node:fs");
+            const fd = openSync(logPath, "r");
+            const buf = Buffer.alloc(currentSize - lastSize);
+            readSync(fd, buf, 0, buf.length, lastSize);
+            closeSync(fd);
+            lastSize = currentSize;
+            const newLines = buf.toString("utf-8").split("\n").filter(Boolean);
+            for (const line of newLines) {
+              try {
+                const event = JSON.parse(line);
+                sendEvent("tool-call", event);
+              } catch {
+              }
+            }
+          } catch {
+          }
+        };
+        let logWatcher = null;
+        try {
+          if (existsSync(logPath)) {
+            const { watch } = require("node:fs");
+            logWatcher = watch(logPath, (eventType) => {
+              if (eventType === "change") {
+                pollLogFile();
+              }
+            });
+          }
+        } catch {
+        }
+        const pollInterval = setInterval(pollLogFile, 500);
+        req.on("close", () => {
+          eventBus.off("tool-call", onToolCall);
+          eventBus.off("scan-progress", onScanProgress);
+          eventBus.off("scan-complete", onScanComplete);
+          if (logWatcher) {
+            try {
+              logWatcher.close();
+            } catch {
+            }
+          }
+          clearInterval(pollInterval);
+        });
+        return;
+      }
+      const rawAssetPath = pathname === "/" ? "/index.html" : pathname;
+      const safeAssetPath = join(uiDir, rawAssetPath);
+      if (!safeAssetPath.startsWith(uiDir)) {
+        res.writeHead(403, { "Content-Type": "text/plain" });
+        res.end("Forbidden: Path traversal rejected");
+        return;
+      }
+      if (existsSync(safeAssetPath)) {
+        const ext = extname(safeAssetPath);
+        const contentTypes = {
+          ".html": "text/html",
+          ".js": "application/javascript",
+          ".css": "text/css",
+          ".svg": "image/svg+xml",
+          ".json": "application/json",
+          ".png": "image/png"
+        };
+        const contentType = contentTypes[ext] || "application/octet-stream";
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(readFileSync(safeAssetPath));
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      }
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+  });
+  server.listen(port, host, () => {
+    console.log(`Mapx UI Server running at http://${host}:${port}`);
+  });
+  return server;
+}
+export {
+  startUiServer
+};

package/package.json

@@ -0,0 +1,179 @@
+{
+  "name": "@mgamil/mapx",
+  "version": "0.2.4",
+  "license": "Apache-2.0",
+  "description": "Multi-language code graph memory system for LLMs",
+  "author": {
+    "email": "mgamil.dev@gmail.com",
+    "name": "Mohamed Gamil",
+    "url": "https://gamil.io"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MohamedGamil/mapx.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MohamedGamil/mapx/issues"
+  },
+  "homepage": "https://github.com/MohamedGamil/mapx",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "mapx": "./dist/main.js"
+  },
+  "files": [
+    "dist/",
+    "wasm/",
+    "queries/",
+    "VERSION",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "scripts": {
+    "version-sync": "tsx scripts/sync-version.ts",
+    "dev": "tsx watch src/main.ts",
+    "build:wasm": "tsx scripts/build-wasm.ts",
+    "build:linux": "bun build --compile --minify --bytecode --target=bun-linux-x64 ./src/main.ts --outfile dist/mapx-linux-x64",
+    "build:linux-arm": "bun build --compile --minify --bytecode --target=bun-linux-arm64 ./src/main.ts --outfile dist/mapx-linux-arm64",
+    "build:mac-arm": "bun build --compile --minify --bytecode --target=bun-darwin-arm64 ./src/main.ts --outfile dist/mapx-darwin-arm64",
+    "build:mac-x64": "bun build --compile --minify --bytecode --target=bun-darwin-x64 ./src/main.ts --outfile dist/mapx-darwin-x64",
+    "build:win": "bun build --compile --minify --bytecode --target=bun-windows-x64 ./src/main.ts --outfile dist/mapx-windows-x64.exe",
+    "build:all": "tsx scripts/build-all.ts",
+    "build:npm": "tsup && tsx scripts/build-ui.ts",
+    "prepare": "npm run build:npm",
+    "init": "tsx src/main.ts init",
+    "uninit": "tsx src/main.ts uninit",
+    "scan": "tsx src/main.ts scan",
+    "update": "tsx src/main.ts update",
+    "status": "tsx src/main.ts status",
+    "export": "tsx src/main.ts export",
+    "export:json": "tsx src/main.ts export --format=json",
+    "export:dot": "tsx src/main.ts export --format=dot",
+    "export:svg": "tsx src/main.ts export --format=svg",
+    "export:toon": "tsx src/main.ts export --format=toon",
+    "query": "tsx src/main.ts query",
+    "search": "tsx src/main.ts search",
+    "deps": "tsx src/main.ts deps",
+    "trace": "tsx src/main.ts trace",
+    "callers": "tsx src/main.ts callers",
+    "callees": "tsx src/main.ts callees",
+    "impact": "tsx src/main.ts impact",
+    "node": "tsx src/main.ts node",
+    "files": "tsx src/main.ts files",
+    "clusters": "tsx src/main.ts clusters",
+    "summary": "tsx src/main.ts summary",
+    "ui": "tsx src/main.ts ui",
+    "serve": "tsx src/main.ts serve",
+    "serve:sse": "tsx src/main.ts serve --sse",
+    "lang:list": "tsx src/main.ts lang list",
+    "lang:install": "tsx src/main.ts lang install",
+    "lang:uninstall": "tsx src/main.ts lang uninstall",
+    "agents:list": "tsx src/main.ts agents list",
+    "agents:generate": "tsx src/main.ts agents generate",
+    "agents:mcp": "tsx src/main.ts agents mcp",
+    "agents:mcp-detect": "tsx src/main.ts agents mcp --detect",
+    "routes": "tsx src/main.ts routes",
+    "hooks": "tsx src/main.ts hooks",
+    "workspaces:list": "tsx src/main.ts workspaces list",
+    "workspaces:discover": "tsx src/main.ts workspaces discover",
+    "workspaces:sync": "tsx src/main.ts workspaces sync",
+    "bench": "tsx benchmarks/run.ts",
+    "bench:json": "tsx benchmarks/run.ts --json",
+    "test": "tsx src/main.ts scan && tsx src/main.ts export"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.10.0",
+    "commander": "^13.1.0",
+    "cytoscape": "^3.33.4",
+    "graphology": "^0.26.0",
+    "graphology-metrics": "^2.4.0",
+    "minimatch": "^10.2.5",
+    "tree-sitter-c-sharp": "0.23.5",
+    "tree-sitter-go": "0.25.0",
+    "tree-sitter-java": "0.23.5",
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-php": "^0.24.2",
+    "tree-sitter-python": "0.25.0",
+    "tree-sitter-rust": "0.24.0",
+    "tree-sitter-typescript": "^0.23.2",
+    "uplot": "^1.6.32",
+    "web-tree-sitter": "^0.26.9",
+    "zod": "^3.25.0",
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "optionalDependencies": {},
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/cytoscape": "^3.21.9",
+    "@types/node": "^22.19.19",
+    "esbuild": "^0.28.0",
+    "graphology-types": "^0.24.8",
+    "tree-sitter-c": "^0.23.4",
+    "tree-sitter-cpp": "^0.23.4",
+    "tree-sitter-dart": "^1.0.0",
+    "tree-sitter-kotlin": "^0.3.8",
+    "tree-sitter-ruby": "^0.23.1",
+    "tree-sitter-scala": "^0.24.0",
+    "tree-sitter-swift": "^0.7.1",
+    "tree-sitter-vue": "^0.2.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "mapx",
+    "ai",
+    "llm",
+    "agent",
+    "mcp",
+    "mcp-server",
+    "agentic",
+    "code-memory",
+    "code-graph",
+    "code-understanding",
+    "code-knowledge",
+    "code-intelligence",
+    "code-analysis",
+    "multi-language",
+    "llm-tool",
+    "semantic-analysis",
+    "dependency-graph",
+    "code-navigation",
+    "refactoring",
+    "code-search",
+    "typescript",
+    "python",
+    "javascript",
+    "java",
+    "go",
+    "c#",
+    "c++",
+    "kotlin",
+    "swift",
+    "rust",
+    "php",
+    "vue",
+    "react",
+    "flask",
+    "django",
+    "laravel",
+    "ai-coding",
+    "tree-sitter"
+  ]
+}