@launchsecure/launch-kit 0.0.1

package/dist/server/graph-mcp-entry.js

@@ -0,0 +1,1542 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/server/graph-mcp.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
+
+// src/server/graph/index.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
+
+// src/server/graph/parsers/ui/react-nextjs.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/server/graph/core/ast-helpers.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var tsModule;
+function getTs() {
+  if (!tsModule) {
+    tsModule = require("typescript");
+  }
+  return tsModule;
+}
+function parseFile(absPath) {
+  const ts = getTs();
+  const content = (0, import_node_fs.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path.extname)(absPath);
+  const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ext === ".ts" ? ts.ScriptKind.TS : ext === ".jsx" ? ts.ScriptKind.JSX : ts.ScriptKind.JS;
+  const sourceFile = ts.createSourceFile(
+    absPath,
+    content,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    scriptKind
+  );
+  const exportsSet = /* @__PURE__ */ new Set();
+  const exportsOrdered = [];
+  let defaultName = null;
+  let firstValueExport = null;
+  let firstTypeExport = null;
+  const imports = [];
+  const reExports = [];
+  const jsxElements = /* @__PURE__ */ new Set();
+  const navigations = [];
+  function addExport(name2, kind) {
+    if (!exportsSet.has(name2)) {
+      exportsSet.add(name2);
+      exportsOrdered.push(name2);
+    }
+    if (kind === "default") defaultName = name2;
+    else if (kind === "value" && !firstValueExport) firstValueExport = name2;
+    else if (kind === "type" && !firstTypeExport) firstTypeExport = name2;
+  }
+  function hasModifier(node, kind) {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+    return modifiers?.some((m) => m.kind === kind) ?? false;
+  }
+  function extractTargetFromExpression(expr) {
+    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+      return { target: expr.text, isTemplate: false };
+    }
+    if (ts.isTemplateExpression(expr)) {
+      return { target: expr.getText(sourceFile), isTemplate: true };
+    }
+    return null;
+  }
+  function visit(node) {
+    if (ts.isImportDeclaration(node)) {
+      const moduleSpec = node.moduleSpecifier;
+      if (ts.isStringLiteral(moduleSpec)) {
+        const specifier = moduleSpec.text;
+        const clause = node.importClause;
+        const isTypeOnly = !!clause?.isTypeOnly;
+        const names = [];
+        const typeNames = /* @__PURE__ */ new Set();
+        if (clause) {
+          if (clause.name) names.push(clause.name.text);
+          const nb = clause.namedBindings;
+          if (nb && ts.isNamedImports(nb)) {
+            for (const el of nb.elements) {
+              names.push(el.name.text);
+              if (el.isTypeOnly) typeNames.add(el.name.text);
+            }
+          } else if (nb && ts.isNamespaceImport(nb)) {
+            names.push(nb.name.text);
+          }
+        }
+        if (names.length > 0 || isTypeOnly) {
+          imports.push({ names, specifier, isTypeOnly, typeNames });
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node)) {
+      const fromSpec = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
+      if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+        for (const el of node.exportClause.elements) {
+          const exportedName = el.name.text;
+          addExport(exportedName, "value");
+          if (fromSpec) {
+            reExports.push({ name: exportedName, from: fromSpec });
+          }
+        }
+      }
+    }
+    if (ts.isExportAssignment(node) && !node.isExportEquals) {
+      if (ts.isIdentifier(node.expression)) {
+        addExport(node.expression.text, "default");
+      } else {
+        if (!defaultName) defaultName = "default";
+      }
+    }
+    if (ts.isFunctionDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      const isDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
+      if (node.name) addExport(node.name.text, isDefault ? "default" : "value");
+    }
+    if (ts.isVariableStatement(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name)) {
+          addExport(decl.name.text, "value");
+        }
+      }
+    }
+    if (ts.isClassDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      const isDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
+      if (node.name) addExport(node.name.text, isDefault ? "default" : "value");
+    }
+    if (ts.isTypeAliasDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      addExport(node.name.text, "type");
+    }
+    if (ts.isInterfaceDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      addExport(node.name.text, "type");
+    }
+    if (ts.isEnumDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
+      addExport(node.name.text, "value");
+    }
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const tagName = node.tagName;
+      if (ts.isIdentifier(tagName) && /^[A-Z]/.test(tagName.text)) {
+        jsxElements.add(tagName.text);
+      } else if (ts.isPropertyAccessExpression(tagName)) {
+        let root = tagName;
+        while (ts.isPropertyAccessExpression(root)) root = root.expression;
+        if (ts.isIdentifier(root) && /^[A-Z]/.test(root.text)) {
+          jsxElements.add(root.text);
+        }
+      }
+    }
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "router" && (expr.name.text === "push" || expr.name.text === "replace")) {
+        const arg = node.arguments[0];
+        if (arg) {
+          const parsed = extractTargetFromExpression(arg);
+          if (parsed) {
+            navigations.push({
+              kind: expr.name.text === "push" ? "router-push" : "router-replace",
+              target: parsed.target,
+              isTemplate: parsed.isTemplate
+            });
+          }
+        }
+      }
+    }
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const tagName = node.tagName;
+      if (ts.isIdentifier(tagName) && tagName.text === "Link") {
+        for (const attr of node.attributes.properties) {
+          if (ts.isJsxAttribute(attr) && attr.name.getText(sourceFile) === "href" && attr.initializer) {
+            const init = attr.initializer;
+            if (ts.isStringLiteral(init)) {
+              navigations.push({ kind: "link-href", target: init.text, isTemplate: false });
+            } else if (ts.isJsxExpression(init) && init.expression) {
+              const parsed = extractTargetFromExpression(init.expression);
+              if (parsed) {
+                navigations.push({ kind: "link-href", target: parsed.target, isTemplate: parsed.isTemplate });
+              }
+            }
+          }
+        }
+      }
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const left = node.left;
+      if (ts.isPropertyAccessExpression(left) && ts.isPropertyAccessExpression(left.expression) && ts.isIdentifier(left.expression.expression) && left.expression.expression.text === "window" && left.expression.name.text === "location" && left.name.text === "href") {
+        const parsed = extractTargetFromExpression(node.right);
+        if (parsed) {
+          navigations.push({ kind: "window-location", target: parsed.target, isTemplate: parsed.isTemplate });
+        }
+      }
+    }
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isPropertyAccessExpression(expr) && ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.expression) && expr.expression.expression.text === "window" && expr.expression.name.text === "location" && (expr.name.text === "assign" || expr.name.text === "replace")) {
+        const arg = node.arguments[0];
+        if (arg) {
+          const parsed = extractTargetFromExpression(arg);
+          if (parsed) {
+            navigations.push({ kind: "window-location", target: parsed.target, isTemplate: parsed.isTemplate });
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
+  return {
+    name,
+    exports: exportsOrdered,
+    imports,
+    reExports,
+    jsxElements,
+    navigations
+  };
+}
+var MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert",
+  "delete",
+  "deleteMany"
+]);
+function extractDbCalls(absPath) {
+  const ts = getTs();
+  const content = (0, import_node_fs.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path.extname)(absPath);
+  const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.Latest, true, scriptKind);
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isPropertyAccessExpression(expr) && ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.expression) && expr.expression.expression.text === "db") {
+        const model = expr.expression.name.text;
+        const method = expr.name.text;
+        const key = `${model}.${method}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          calls.push({
+            model,
+            method,
+            isMutation: MUTATION_METHODS.has(method)
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return calls;
+}
+function extractAuthWrappers(absPath) {
+  const ts = getTs();
+  const content = (0, import_node_fs.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path.extname)(absPath);
+  const scriptKind = ext === ".tsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.Latest, true, scriptKind);
+  const wrappers = /* @__PURE__ */ new Set();
+  const AUTH_WRAPPERS = /* @__PURE__ */ new Set(["withAuth", "withPermission", "withRole", "requireAuth"]);
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      if (AUTH_WRAPPERS.has(node.expression.text)) {
+        wrappers.add(node.expression.text);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return wrappers;
+}
+
+// src/server/graph/parsers/ui/react-nextjs.ts
+var RENDER_TYPES = /* @__PURE__ */ new Set(["component", "ui", "layout", "context"]);
+function walk(dir, exts) {
+  const results = [];
+  if (!(0, import_node_fs2.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path2.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk(full, exts));
+    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function toNodeId(srcDir, absPath) {
+  return (0, import_node_path2.relative)(srcDir, absPath).replace(/\\/g, "/");
+}
+function resolveImport(srcDir, specifier) {
+  if (!specifier.startsWith("@/")) return null;
+  const rel = specifier.slice(2);
+  const base = (0, import_node_path2.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path2.join)(base, "index.ts"), (0, import_node_path2.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs2.existsSync)(c) && (0, import_node_fs2.statSync)(c).isFile()) return c;
+  }
+  return null;
+}
+function resolveRelativeImport(fromFile, specifier) {
+  const base = (0, import_node_path2.join)((0, import_node_path2.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path2.join)(base, "index.ts"), (0, import_node_path2.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs2.existsSync)(c) && (0, import_node_fs2.statSync)(c).isFile()) return c;
+  }
+  return null;
+}
+function buildAllBarrelMaps(srcDir, parsedByPath) {
+  const barrels = /* @__PURE__ */ new Map();
+  for (const [absPath, parsed] of parsedByPath) {
+    const bn = (0, import_node_path2.basename)(absPath);
+    if (bn !== "index.ts" && bn !== "index.tsx") continue;
+    if (parsed.reExports.length === 0) continue;
+    const barrelId = (0, import_node_path2.relative)(srcDir, (0, import_node_path2.dirname)(absPath)).replace(/\\/g, "/");
+    const map = /* @__PURE__ */ new Map();
+    for (const re of parsed.reExports) {
+      if (!re.from.startsWith(".")) continue;
+      const resolved = resolveRelativeImport(absPath, re.from);
+      if (resolved) map.set(re.name, resolved);
+    }
+    if (map.size > 0) barrels.set(barrelId, map);
+  }
+  return barrels;
+}
+function classifyType(id) {
+  if (id.endsWith("/page.tsx")) return "page";
+  if (id.endsWith("/layout.tsx")) return "layout";
+  if (id.startsWith("client/components/ui/")) return "ui";
+  if (id.startsWith("client/components/")) return "component";
+  if (id.startsWith("client/hooks/")) return "hook";
+  if (/client\/lib\/.*-context\./.test(id)) return "context";
+  if (id.startsWith("client/lib/")) return id.includes("config") ? "config" : "util";
+  if (id.startsWith("client/api/")) return "util";
+  if (id.startsWith("server/mcp/")) return "mcp-tool";
+  if (id.startsWith("server/lib/")) return "lib";
+  if (id.startsWith("server/")) return "lib";
+  if (id.startsWith("lib/") || id.startsWith("config/")) return "lib";
+  return "component";
+}
+function classifyModule(id) {
+  if (/app\/\(auth\)\//.test(id)) return "auth";
+  if (/app\/\(admin\)\//.test(id)) return "admin";
+  if (/app\/\(settings\)\//.test(id)) return "settings";
+  if (/app\/\(app\)\/\[orgSlug\]\/\(project-pages\)\//.test(id)) return "project";
+  if (/app\/\(app\)\/\[orgSlug\]\/\(org-pages\)\//.test(id)) return "org";
+  if (/app\/\(app\)\/\[orgSlug\]\//.test(id)) return "org";
+  if (id.startsWith("app/integrations/")) return "integrations";
+  if (id.startsWith("app/docs/")) return "admin";
+  if (id.startsWith("client/components/ui/")) return "shared-ui";
+  if (id.startsWith("client/components/layout/") || /client\/lib\/navigation/.test(id)) return "layout";
+  if (/client\/components\/auth\//.test(id) || /client\/lib\/auth-/.test(id) || /client\/lib\/github-oauth/.test(id) || /client\/lib\/permission-service/.test(id) || /client\/hooks\/use-permissions/.test(id)) return "auth";
+  if (/client\/components\/prd-/.test(id) || /client\/hooks\/use-admin/.test(id)) return "admin";
+  if (/client\/components\/org-/.test(id) || /client\/hooks\/use-org-/.test(id) || /client\/hooks\/use-provider-def/.test(id)) return "org";
+  if (/client\/components\/project/.test(id) || /client\/hooks\/use-project-/.test(id) || /client\/hooks\/use-pipeline/.test(id) || /client\/hooks\/use-databases/.test(id) || /client\/hooks\/use-provider-env/.test(id) || /client\/hooks\/use-role-assign/.test(id) || /client\/components\/pipeline/.test(id) || /client\/components\/deployments/.test(id)) return "project";
+  if (/client\/hooks\/use-(profile|sessions|organizations|notification)/.test(id)) return "settings";
+  if (id.startsWith("server/auth/")) return "auth";
+  if (id.startsWith("server/mcp/")) return "mcp";
+  if (id.startsWith("server/lib/")) return "server-lib";
+  if (id.startsWith("server/middleware")) return "middleware";
+  if (id.startsWith("server/services/")) return "services";
+  if (id.startsWith("server/db")) return "db";
+  if (id.startsWith("server/errors")) return "errors";
+  if (id.startsWith("server/")) return "server-lib";
+  if (id.startsWith("config/")) return "config";
+  if (id.startsWith("lib/")) return "lib";
+  return "root";
+}
+function extractRoute(id) {
+  if (!id.endsWith("/page.tsx")) return null;
+  let route = id.replace(/^app\//, "/").replace(/\/page\.tsx$/, "");
+  route = route.replace(/\/\([^)]+\)/g, "");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  route = route.replace(/\/+/g, "/");
+  if (!route.startsWith("/")) route = "/" + route;
+  return route || "/";
+}
+function nameFromFilename(absPath) {
+  return (0, import_node_path2.basename)(absPath, (0, import_node_path2.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
+}
+function resolveTemplateLiteralRoute(template, routeToNodeId) {
+  const parameterized = template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    const cleaned = expr.trim();
+    if (cleaned.includes(".")) {
+      const parts = cleaned.split(".");
+      const last = parts[parts.length - 1];
+      const secondLast = parts.length > 1 ? parts[parts.length - 2] : "";
+      if (last === "slug" && secondLast === "project") return ":projectSlug";
+      if (last === "slug") return ":projectSlug";
+      if (last === "id" && /cred/i.test(secondLast)) return ":credentialId";
+      if (last === "id" && /run/i.test(secondLast)) return ":runId";
+      if (last === "sha") return ":commitSha";
+      if (last === "id") return ":id";
+      return `:${last}`;
+    }
+    if (/orgSlug/i.test(cleaned)) return ":orgSlug";
+    if (/projectSlug/i.test(cleaned)) return ":projectSlug";
+    if (/runId/i.test(cleaned)) return ":runId";
+    if (/credentialId/i.test(cleaned)) return ":credentialId";
+    if (/commitSha/i.test(cleaned)) return ":commitSha";
+    if (/token/i.test(cleaned)) return ":token";
+    return `:${cleaned}`;
+  });
+  const normalized = parameterized.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+  if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
+  let bestScore = -1;
+  let bestId = null;
+  for (const [route, nodeId] of routeToNodeId) {
+    const score = routeMatchScore(normalized, route);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = nodeId;
+    }
+  }
+  return bestScore > 0 ? bestId : null;
+}
+function routeMatchScore(candidate, known) {
+  const segsA = candidate.split("/");
+  const segsB = known.split("/");
+  if (segsA.length !== segsB.length) return -1;
+  let score = 0;
+  for (let i = 0; i < segsA.length; i++) {
+    const a = segsA[i], b = segsB[i];
+    if (a === b) {
+      score += 3;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      score += 0;
+      continue;
+    }
+    return -1;
+  }
+  return score;
+}
+function templateToRoute(template) {
+  return template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    const cleaned = expr.trim();
+    if (cleaned.includes(".")) {
+      const parts = cleaned.split(".");
+      const last = parts[parts.length - 1];
+      const secondLast = parts.length > 1 ? parts[parts.length - 2] : "";
+      if (last === "slug" && /project/i.test(secondLast)) return ":projectSlug";
+      if (last === "slug") return ":slug";
+      if (last === "sha") return ":commitSha";
+      return `:${last}`;
+    }
+    return `:${cleaned}`;
+  });
+}
+function matchRouteToPage(route, routeToNodeId) {
+  const normalized = route.replace(/\/$/, "") || "/";
+  if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
+  return null;
+}
+function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap, barrelMaps, routeToNodeId) {
+  const edges = [];
+  const flagged = [];
+  const seen = /* @__PURE__ */ new Set();
+  function addEdge(target, type, label) {
+    const key = `${sourceId}\u2192${target}\u2192${type}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const edge = { source: sourceId, target, type };
+    if (label) edge.label = label;
+    edges.push(edge);
+  }
+  function edgeTypeFor(targetId, isTypeOnlyImport, importedNames) {
+    if (isTypeOnlyImport) return "imports";
+    const targetType = nodeTypeMap.get(targetId);
+    if (targetType && RENDER_TYPES.has(targetType)) {
+      const anyRendered = importedNames.some((n) => parsed.jsxElements.has(n));
+      if (anyRendered) return "renders";
+    }
+    return "imports";
+  }
+  for (const imp of parsed.imports) {
+    const { names, specifier, isTypeOnly, typeNames } = imp;
+    if (specifier.startsWith("@/")) {
+      const relToSrc = specifier.slice(2);
+      const barrelMap = barrelMaps.get(relToSrc);
+      if (barrelMap && names.length > 0) {
+        const byTarget = /* @__PURE__ */ new Map();
+        for (const name of names) {
+          const targetAbs = barrelMap.get(name);
+          if (targetAbs) {
+            const targetId = toNodeId(srcDir, targetAbs);
+            if (nodeIdSet.has(targetId)) {
+              if (!byTarget.has(targetId)) byTarget.set(targetId, []);
+              byTarget.get(targetId).push(name);
+            }
+          }
+        }
+        for (const [targetId, targetNames] of byTarget) {
+          const allType = isTypeOnly || targetNames.every((n) => typeNames.has(n));
+          addEdge(targetId, edgeTypeFor(targetId, allType, targetNames));
+        }
+      } else {
+        const resolved = resolveImport(srcDir, specifier);
+        if (resolved) {
+          const targetId = toNodeId(srcDir, resolved);
+          if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
+            addEdge(targetId, edgeTypeFor(targetId, isTypeOnly, names));
+          }
+        }
+      }
+    } else if (specifier.startsWith(".")) {
+      const resolved = resolveRelativeImport(absPath, specifier);
+      if (resolved) {
+        const targetId = toNodeId(srcDir, resolved);
+        if (nodeIdSet.has(targetId) && !targetId.endsWith("/index.ts") && !targetId.endsWith("/index.tsx")) {
+          addEdge(targetId, edgeTypeFor(targetId, isTypeOnly, names));
+        }
+      }
+    }
+  }
+  for (const nav of parsed.navigations) {
+    if (nav.kind === "window-location") {
+      flagged.push({
+        source: sourceId,
+        target: "EXTERNAL",
+        type: "navigates",
+        label: `window.location to ${nav.target}`,
+        confidence: "high"
+      });
+      continue;
+    }
+    if (!nav.isTemplate) {
+      const targetId = matchRouteToPage(nav.target, routeToNodeId);
+      if (targetId && targetId !== sourceId) {
+        const label = nav.kind === "link-href" ? `Link to ${nav.target}` : `router.${nav.kind === "router-push" ? "push" : "replace"}('${nav.target}')`;
+        addEdge(targetId, "navigates", label);
+      }
+    } else {
+      const template = nav.target.replace(/^`|`$/g, "");
+      if (!template.includes("${")) continue;
+      const targetId = resolveTemplateLiteralRoute(template, routeToNodeId);
+      if (targetId && targetId !== sourceId) {
+        const label = nav.kind === "link-href" ? `Link to ${templateToRoute(template)}` : `router.${nav.kind === "router-push" ? "push" : "replace"}('${templateToRoute(template)}')`;
+        addEdge(targetId, "navigates", label);
+      } else {
+        flagged.push({
+          source: sourceId,
+          target: "DYNAMIC",
+          type: "navigates",
+          label: nav.kind === "link-href" ? `Link with template: \`${template}\`` : `router.${nav.kind === "router-push" ? "push" : "replace"} with template: \`${template}\``,
+          confidence: "medium"
+        });
+      }
+    }
+  }
+  return { edges, flagged };
+}
+function detect(rootDir) {
+  return (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "src", "app")) && (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "next.config.ts")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "next.config.js")) || (0, import_node_fs2.existsSync)((0, import_node_path2.join)(rootDir, "next.config.mjs"));
+}
+function generate(rootDir) {
+  const srcDir = (0, import_node_path2.join)(rootDir, "src");
+  const appFiles = walk((0, import_node_path2.join)(srcDir, "app"), [".tsx", ".ts"]).filter(
+    (f) => f.endsWith("/page.tsx") || f.endsWith("/layout.tsx")
+  );
+  const clientFiles = walk((0, import_node_path2.join)(srcDir, "client"), [".tsx", ".ts"]);
+  const serverFiles = walk((0, import_node_path2.join)(srcDir, "server"), [".ts", ".tsx"]).filter(
+    (f) => (0, import_node_path2.basename)(f) !== "route.ts" && (0, import_node_path2.basename)(f) !== "route.tsx"
+  );
+  const libFiles = walk((0, import_node_path2.join)(srcDir, "lib"), [".ts", ".tsx"]);
+  const configFiles = walk((0, import_node_path2.join)(srcDir, "config"), [".ts", ".tsx"]);
+  const allDiscovered = [...appFiles, ...clientFiles, ...serverFiles, ...libFiles, ...configFiles];
+  const parsedByPath = /* @__PURE__ */ new Map();
+  for (const absPath of allDiscovered) {
+    parsedByPath.set(absPath, parseFile(absPath));
+  }
+  const barrelMaps = buildAllBarrelMaps(srcDir, parsedByPath);
+  const fileSet = allDiscovered.filter((f) => !(0, import_node_path2.basename)(f).startsWith("index."));
+  const nodes = [];
+  const nodeIdSet = /* @__PURE__ */ new Set();
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  const routeToNodeId = /* @__PURE__ */ new Map();
+  for (const absPath of fileSet) {
+    const id = toNodeId(srcDir, absPath);
+    const type = classifyType(id);
+    const parsed = parsedByPath.get(absPath);
+    const name = parsed.name || nameFromFilename(absPath);
+    const route = extractRoute(id);
+    const module_ = classifyModule(id);
+    nodes.push({ id, type, name, route, module: module_, exports: parsed.exports });
+    nodeIdSet.add(id);
+    nodeTypeMap.set(id, type);
+    if (route) routeToNodeId.set(route, id);
+  }
+  const allEdges = [];
+  const allFlagged = [];
+  for (const absPath of fileSet) {
+    const sourceId = toNodeId(srcDir, absPath);
+    const parsed = parsedByPath.get(absPath);
+    const { edges, flagged } = extractEdges(
+      srcDir,
+      absPath,
+      sourceId,
+      parsed,
+      nodeIdSet,
+      nodeTypeMap,
+      barrelMaps,
+      routeToNodeId
+    );
+    allEdges.push(...edges);
+    allFlagged.push(...flagged);
+  }
+  const flaggedSet = /* @__PURE__ */ new Set();
+  const dedupedFlagged = allFlagged.filter((f) => {
+    const key = `${f.source}\u2192${f.target}\u2192${f.label}`;
+    if (flaggedSet.has(key)) return false;
+    flaggedSet.add(key);
+    return true;
+  });
+  const typePriority = {
+    layout: 0,
+    page: 1,
+    component: 2,
+    ui: 3,
+    context: 4,
+    config: 5,
+    util: 6,
+    hook: 7,
+    lib: 8
+  };
+  nodes.sort((a, b) => (typePriority[a.type] ?? 99) - (typePriority[b.type] ?? 99) || a.id.localeCompare(b.id));
+  allEdges.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  const byType = (t) => nodes.filter((n) => n.type === t).length;
+  const stats = {
+    total_pages: byType("page"),
+    total_layouts: byType("layout"),
+    total_components: byType("component"),
+    total_ui: byType("ui"),
+    total_hooks: byType("hook"),
+    total_contexts: byType("context"),
+    total_configs: byType("config"),
+    total_utils: byType("util"),
+    total_libs: byType("lib"),
+    total_edges: allEdges.length,
+    total_flagged: dedupedFlagged.length
+  };
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "main-app-only",
+      app_root: "src/",
+      layer: "ui",
+      parser: "react-nextjs-ast",
+      ...stats,
+      notes: "Auto-generated via TypeScript AST \u2014 edges derived from actual imports, renders from JSX usage, navigations from router/Link calls."
+    },
+    nodes,
+    edges: allEdges,
+    cross_refs: [],
+    contradictions: [],
+    warnings: [],
+    flagged_edges: dedupedFlagged,
+    patterns: {
+      total_nodes: nodes.length,
+      by_type: stats,
+      by_edge_type: {
+        renders: allEdges.filter((e) => e.type === "renders").length,
+        imports: allEdges.filter((e) => e.type === "imports").length,
+        navigates: allEdges.filter((e) => e.type === "navigates").length
+      }
+    }
+  };
+}
+var reactNextjsParser = {
+  id: "react-nextjs",
+  layer: "ui",
+  detect,
+  generate
+};
+
+// src/server/graph/parsers/api/nextjs-routes.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+function walk2(dir) {
+  const results = [];
+  if (!(0, import_node_fs3.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path3.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk2(full));
+    } else if (entry.name === "route.ts" || entry.name === "route.tsx") {
+      results.push(full);
+    }
+  }
+  return results;
+}
+function filePathToRoute(apiDir, absPath) {
+  let route = "/" + (0, import_node_path3.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
+  route = route.replace(/\[([^\]]+)\]/g, ":$1");
+  route = route.replace(/\/+/g, "/");
+  if (route === "/") return "/api";
+  return "/api" + route;
+}
+function camelToPascal(s) {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function detect2(rootDir) {
+  return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "src", "app", "api"));
+}
+function generate2(rootDir) {
+  const apiDir = (0, import_node_path3.join)(rootDir, "src", "app", "api");
+  const routeFiles = walk2(apiDir);
+  const nodes = [];
+  const edges = [];
+  const crossRefs = [];
+  const mutatorCount = {};
+  const authUsage = {};
+  let endpointsWithAuth = 0;
+  let endpointsWithDbAccess = 0;
+  for (const absPath of routeFiles) {
+    const parsed = parseFile(absPath);
+    const dbCalls = extractDbCalls(absPath);
+    const authWrappers = extractAuthWrappers(absPath);
+    const methods = [];
+    for (const exp of parsed.exports) {
+      if (HTTP_METHODS.has(exp)) methods.push(exp);
+    }
+    const routePath = filePathToRoute(apiDir, absPath);
+    const relPath = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const mutations = dbCalls.filter((c) => c.isMutation);
+    const reads = dbCalls.filter((c) => !c.isMutation);
+    const mutates = mutations.length > 0;
+    if (mutates) {
+      for (const m of mutations) {
+        mutatorCount[m.method] = (mutatorCount[m.method] ?? 0) + 1;
+      }
+    }
+    if (dbCalls.length > 0) endpointsWithDbAccess++;
+    const authStrategy = [];
+    for (const w of authWrappers) {
+      authStrategy.push(w);
+      authUsage[w] = (authUsage[w] ?? 0) + 1;
+    }
+    if (authStrategy.length > 0) endpointsWithAuth++;
+    nodes.push({
+      id: relPath,
+      type: "endpoint",
+      name: routePath,
+      path: routePath,
+      methods,
+      handler: relPath,
+      // Behavioral classification from handler body (AST-derived).
+      mutates,
+      auth: authStrategy.length > 0 ? authStrategy : ["public"],
+      db_models: [...new Set(dbCalls.map((c) => c.model))],
+      db_operations: [...new Set(dbCalls.map((c) => `${c.model}.${c.method}`))]
+    });
+    const seenModels = /* @__PURE__ */ new Set();
+    for (const call of dbCalls) {
+      if (seenModels.has(call.model)) continue;
+      seenModels.add(call.model);
+      crossRefs.push({
+        source: relPath,
+        target: camelToPascal(call.model),
+        type: call.isMutation ? "mutates" : "reads",
+        layer: "db"
+      });
+    }
+  }
+  nodes.sort((a, b) => a.path.localeCompare(b.path));
+  crossRefs.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  const mutatorNodes = nodes.filter((n) => n.mutates).length;
+  const readOnlyNodes = nodes.filter((n) => !n.mutates).length;
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "main-app-only",
+      stack: "nextjs-app-router",
+      layer: "api",
+      parser: "nextjs-routes-ast",
+      total_endpoints: nodes.length,
+      total_methods: nodes.reduce((sum, n) => sum + n.methods.length, 0),
+      endpoints_with_auth: endpointsWithAuth,
+      endpoints_with_db_access: endpointsWithDbAccess,
+      mutator_endpoints: mutatorNodes,
+      read_only_endpoints: readOnlyNodes
+    },
+    nodes,
+    edges,
+    cross_refs: crossRefs,
+    contradictions: [],
+    warnings: [],
+    flagged_edges: [],
+    patterns: {
+      total_endpoints: nodes.length,
+      methods_breakdown: [...HTTP_METHODS].reduce((acc, m) => {
+        acc[m] = nodes.filter((n) => n.methods.includes(m)).length;
+        return acc;
+      }, {}),
+      auth_strategies: authUsage,
+      mutation_operations: mutatorCount,
+      mutator_vs_reader: { mutators: mutatorNodes, readers: readOnlyNodes }
+    }
+  };
+}
+var nextjsRoutesParser = {
+  id: "nextjs-routes",
+  layer: "api",
+  detect: detect2,
+  generate: generate2
+};
+
+// src/server/graph/parsers/db/prisma-schema.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
+function parseModels(content) {
+  const nodes = [];
+  const relations = [];
+  const modelRe = /model\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = modelRe.exec(content)) !== null) {
+    const modelName = m[1];
+    const body = m[2];
+    const columns = [];
+    const lines = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("@@"));
+    for (const line of lines) {
+      const fieldMatch = line.match(/^(\w+)\s+(\S+)(.*)/);
+      if (!fieldMatch) continue;
+      const fieldName = fieldMatch[1];
+      const fieldType = fieldMatch[2];
+      const rest = fieldMatch[3] ?? "";
+      const commentMatch = rest.match(/\/\/\s*(.+)$/);
+      const comment = commentMatch ? commentMatch[1].trim() : null;
+      const restNoComment = commentMatch ? rest.slice(0, commentMatch.index).trim() : rest;
+      const isPrimary = restNoComment.includes("@id");
+      const isUnique = restNoComment.includes("@unique");
+      const isNullable = fieldType.endsWith("?");
+      const baseType = fieldType.replace(/[?\[\]]/g, "");
+      const defaultMatch = restNoComment.match(/@default\(([^)]+)\)/);
+      const defaultVal = defaultMatch ? defaultMatch[1] : null;
+      const relationMatch = restNoComment.match(/@relation\(([^)]*)\)/);
+      const isRelationField = !!relationMatch;
+      columns.push({
+        name: fieldName,
+        type: fieldType,
+        primary: isPrimary,
+        unique: isUnique,
+        nullable: isNullable,
+        default: defaultVal,
+        isRelation: isRelationField,
+        comment
+      });
+      if (relationMatch) {
+        const relArgs = relationMatch[1];
+        const fieldsMatch = relArgs.match(/fields:\s*\[([^\]]+)\]/);
+        const refsMatch = relArgs.match(/references:\s*\[([^\]]+)\]/);
+        const onDeleteMatch = relArgs.match(/onDelete:\s*(\w+)/);
+        if (fieldsMatch && refsMatch) {
+          const fk = fieldsMatch[1].trim();
+          relations.push({
+            source: modelName,
+            target: baseType,
+            type: "belongs_to",
+            fk,
+            onDelete: onDeleteMatch ? onDeleteMatch[1] : null
+          });
+        }
+      }
+      if (fieldType.endsWith("[]") && !relationMatch) {
+        relations.push({
+          source: modelName,
+          target: baseType,
+          type: "has_many",
+          fk: null,
+          onDelete: null
+        });
+      }
+    }
+    nodes.push({
+      id: modelName,
+      type: "table",
+      name: modelName,
+      columns: columns.filter((c) => !c.isRelation || c.primary)
+    });
+  }
+  return { nodes, relations };
+}
+function parseEnums(content) {
+  const nodes = [];
+  const enumRe = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+  let m;
+  while ((m = enumRe.exec(content)) !== null) {
+    const enumName = m[1];
+    const body = m[2];
+    const values = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//"));
+    nodes.push({
+      id: enumName,
+      type: "enum",
+      name: enumName,
+      values
+    });
+  }
+  return nodes;
+}
+function detect3(rootDir) {
+  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "prisma", "schema.prisma"));
+}
+function generate3(rootDir) {
+  const schemaPath = (0, import_node_path4.join)(rootDir, "prisma", "schema.prisma");
+  const content = (0, import_node_fs4.readFileSync)(schemaPath, "utf-8");
+  const { nodes: modelNodes, relations } = parseModels(content);
+  const enumNodes = parseEnums(content);
+  const allNodes = [...modelNodes, ...enumNodes];
+  const edges = relations.map((r) => ({
+    source: r.source,
+    target: r.target,
+    type: r.type,
+    fk: r.fk,
+    onDelete: r.onDelete
+  }));
+  allNodes.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "table" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  edges.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+  return {
+    metadata: {
+      generated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      scope: "prisma-schema",
+      source: "prisma/schema.prisma",
+      provider: "postgresql",
+      layer: "db",
+      total_models: modelNodes.length,
+      total_enums: enumNodes.length,
+      total_relations: edges.length
+    },
+    nodes: allNodes,
+    edges,
+    cross_refs: [],
+    contradictions: [],
+    warnings: [
+      {
+        type: "schema_file_only",
+        detail: "Live DB introspection not yet implemented. Graph derived from prisma/schema.prisma."
+      }
+    ],
+    flagged_edges: [],
+    patterns: {
+      total_tables: modelNodes.length,
+      total_enums: enumNodes.length,
+      total_relations: edges.length,
+      relation_types: {
+        belongs_to: edges.filter((e) => e.type === "belongs_to").length,
+        has_many: edges.filter((e) => e.type === "has_many").length
+      }
+    }
+  };
+}
+var prismaSchemaParser = {
+  id: "prisma-schema",
+  layer: "db",
+  detect: detect3,
+  generate: generate3
+};
+
+// src/server/graph/core/graph-builder.ts
+var ALL_PARSERS = [
+  reactNextjsParser,
+  nextjsRoutesParser,
+  prismaSchemaParser
+];
+function getParser(layer) {
+  return ALL_PARSERS.find((p) => p.layer === layer);
+}
+function generateLayer(rootDir, layer) {
+  const parser = getParser(layer);
+  if (!parser) return null;
+  if (!parser.detect(rootDir)) return null;
+  const output = parser.generate(rootDir);
+  return {
+    layer,
+    output,
+    nodeCount: output.nodes.length,
+    edgeCount: output.edges.length
+  };
+}
+function generateAll(rootDir) {
+  const layers = ["ui", "api", "db"];
+  const results = [];
+  for (const layer of layers) {
+    const result = generateLayer(rootDir, layer);
+    if (result) results.push(result);
+  }
+  return results;
+}
+
+// src/server/graph/index.ts
+var GRAPHS_DIR = ".launchsecure/graphs";
+var LAYERS = ["ui", "api", "db"];
+var graphCache = /* @__PURE__ */ new Map();
+function graphsDir(rootDir) {
+  return (0, import_node_path5.join)(rootDir, GRAPHS_DIR);
+}
+function graphFilePath(rootDir, layer) {
+  return (0, import_node_path5.join)(graphsDir(rootDir), `${layer}.json`);
+}
+function invalidateCache(filePath) {
+  graphCache.delete(filePath);
+}
+function readGraph(rootDir, layer) {
+  const filePath = graphFilePath(rootDir, layer);
+  if (!(0, import_node_fs5.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs5.statSync)(filePath);
+  const cached = graphCache.get(filePath);
+  if (cached && cached.mtimeMs === stat.mtimeMs) {
+    return cached.graph;
+  }
+  const content = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
+  const graph = JSON.parse(content);
+  graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
+  return graph;
+}
+function readAllGraphs(rootDir) {
+  const result = {};
+  for (const layer of LAYERS) {
+    const graph = readGraph(rootDir, layer);
+    if (graph) result[layer] = graph;
+  }
+  return result;
+}
+function generateGraph(rootDir, layer) {
+  const dir = graphsDir(rootDir);
+  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+  const results = layer ? [generateLayer(rootDir, layer)].filter((r) => r !== null) : generateAll(rootDir);
+  for (const result of results) {
+    const filePath = graphFilePath(rootDir, result.layer);
+    (0, import_node_fs5.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
+    invalidateCache(filePath);
+  }
+  return results;
+}
+
+// src/server/graph-mcp.ts
+var SERVER_INFO = {
+  name: "launchsecure-graph",
+  version: "0.0.1"
+};
+var TOOLS = [
+  {
+    name: "generate_graph",
+    description: "Regenerate the structural project graph by scanning source code in the current working directory. Parses three layers: UI (React/Next.js pages, layouts, components, hooks, imports/renders/navigation edges), API (Next.js App Router endpoints with HTTP methods), DB (Prisma schema models, enums, belongs_to/has_many relations). Writes JSON to .launchsecure/graphs/{layer}.json and returns node/edge counts. Run this when project structure has changed (new files, moved components, schema updates). Fast: typically <1s. After generation, use read_graph with filters to query.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layer: {
+          type: "string",
+          enum: ["ui", "api", "db"],
+          description: "Specific layer to regenerate. Omit to regenerate all detectable layers."
+        }
+      }
+    }
+  },
+  {
+    name: "read_graph",
+    description: 'Query the structural project graph \u2014 a smart Glob replacement that locates files by type/module/name and returns structural metadata (imports, renders, routes, relations). \n\nUSE THIS FOR: "where is X", "what files are in module Y", "what pages exist under /admin", "what components does Z render", "what tables relate to User", "list all hooks in auth module". \n\nDO NOT USE FOR: finding text/code content (use Grep), reading actual source code (use Read), understanding behavior/logic/patterns (graph has no code semantics \u2014 only names and edges). \n\nQUERY PARAMS (at least one required for node data \u2014 unfiltered calls return summary only to stay in context):\n- search: substring match on node id, name, or route\n- type: filter by node type (ui layer: page, layout, component, ui, hook, context, config, util; api layer: endpoint; db layer: table, enum)\n- module: filter by module (ui layer only: auth, admin, project, org, settings, integrations, shared-ui, layout, root)\n- node_id: return this node + its neighborhood (incoming+outgoing edges within `hops`)\n- hops: neighborhood radius when node_id is set (default 1)\n- minimal: return only id/type/name/module/route per node (skip heavy fields like columns, exports)\n\nBATCH MODE: pass `queries` (array of query objects) to run multiple independent queries in a single call. Each query object uses the same params (layer/search/type/module/node_id/hops/minimal). Returns { batch: true, count, results: [{index, query, result}, ...] }. Use this when you need multiple graph views up-front (e.g. scoping a feature across ui+api+db layers) to save round-trips. When batch mode is used, top-level params are ignored.\n\nReturns: filtered nodes + edges between them. If no filter given, returns per-layer counts and type breakdown only.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        layer: {
+          type: "string",
+          enum: ["ui", "api", "db"],
+          description: "Graph layer to query: ui, api, or db. Required if any filter is provided."
+        },
+        search: {
+          type: "string",
+          description: "Case-insensitive substring match against node id, name, or route."
+        },
+        type: {
+          type: "string",
+          description: 'Filter by node type (e.g. "page", "hook", "component", "endpoint", "table").'
+        },
+        module: {
+          type: "string",
+          description: 'UI layer only \u2014 filter by module (e.g. "auth", "admin", "project", "org").'
+        },
+        node_id: {
+          type: "string",
+          description: "Center node for a neighborhood query. Returns the node + all nodes reachable within `hops` edges."
+        },
+        hops: {
+          type: "number",
+          description: "Neighborhood radius for node_id queries. Default 1 (direct neighbors only)."
+        },
+        minimal: {
+          type: "boolean",
+          description: "Return minimal node fields only (id, type, name, module, route). Default false."
+        },
+        queries: {
+          type: "array",
+          description: "Batch mode \u2014 array of query objects to run in a single call. Each uses the same param schema (layer/search/type/module/node_id/hops/minimal). When set, top-level params are ignored.",
+          items: {
+            type: "object",
+            properties: {
+              layer: { type: "string", enum: ["ui", "api", "db"] },
+              search: { type: "string" },
+              type: { type: "string" },
+              module: { type: "string" },
+              node_id: { type: "string" },
+              hops: { type: "number" },
+              minimal: { type: "boolean" }
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    name: "grep_nodes",
+    description: `Search for text patterns WITHIN files selected by the project graph. Combines structural filtering (type/module/neighborhood) with regex content search \u2014 narrower than plain Grep because it only scans files matching the graph filter, reducing noise from tests, docs, generated code, unrelated modules.
+
+USE THIS FOR: "which auth hooks use JWT decoding", "find TODO comments in pages only", "which deployment writers call Sentry", "what validation schemas exist in form components". It's grep scoped to a structurally-selected file set.
+
+REQUIRED: layer + pattern. At least one filter (search/type/module/node_id) must be set to narrow the file set \u2014 otherwise you are grepping everything and should just use Grep.
+
+FILTER PARAMS (same semantics as read_graph):
+- layer: ui, api, or db
+- search: substring match on node id/name/route
+- type: node type filter
+- module: ui-layer module filter
+- node_id + hops: neighborhood scope
+
+CONTENT PARAMS:
+- pattern: regex to search for (required)
+- case_insensitive: default false
+- context: lines of context around each match (default 2)
+- max_matches: cap on total matches returned (default 50)
+- max_files: cap on files searched (default 50, errors if filter returns more)
+
+Returns: { pattern, filter, files_searched, total_matches, matches: [{file, line, text, context}], truncated }. Note: for db layer, all nodes map to prisma/schema.prisma so matches are deduped by file.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        layer: {
+          type: "string",
+          enum: ["ui", "api", "db"],
+          description: "Graph layer to scope files (required)."
+        },
+        pattern: {
+          type: "string",
+          description: "Regex pattern to search for (required)."
+        },
+        search: { type: "string", description: "Substring match on node id/name/route." },
+        type: { type: "string", description: "Filter by node type." },
+        module: { type: "string", description: "UI layer only \u2014 filter by module." },
+        node_id: { type: "string", description: "Center node for neighborhood scope." },
+        hops: { type: "number", description: "Neighborhood radius (default 1)." },
+        case_insensitive: { type: "boolean", description: "Case-insensitive regex. Default false." },
+        context: { type: "number", description: "Context lines around each match. Default 2." },
+        max_matches: { type: "number", description: "Max matches to return total. Default 50." },
+        max_files: { type: "number", description: "Max files to search. Default 50." }
+      },
+      required: ["layer", "pattern"]
+    }
+  }
+];
+function matchesSearch(node, query) {
+  const q = query.toLowerCase();
+  if (node.id.toLowerCase().includes(q)) return true;
+  if (node.name.toLowerCase().includes(q)) return true;
+  const route = node.route;
+  if (route && route.toLowerCase().includes(q)) return true;
+  return false;
+}
+function toMinimal(nodes) {
+  return nodes.map((n) => {
+    const out = { id: n.id, type: n.type, name: n.name };
+    if (n.module) out.module = n.module;
+    if (n.route) out.route = n.route;
+    if (n.methods) out.methods = n.methods;
+    return out;
+  });
+}
+function neighborhood(graph, centerId, hops) {
+  const center = graph.nodes.find((n) => n.id === centerId);
+  if (!center) return null;
+  const visited = /* @__PURE__ */ new Set([centerId]);
+  let frontier = /* @__PURE__ */ new Set([centerId]);
+  for (let h = 0; h < hops; h++) {
+    const next = /* @__PURE__ */ new Set();
+    for (const edge of graph.edges) {
+      if (frontier.has(edge.source) && !visited.has(edge.target)) next.add(edge.target);
+      if (frontier.has(edge.target) && !visited.has(edge.source)) next.add(edge.source);
+    }
+    for (const id of next) visited.add(id);
+    frontier = next;
+    if (frontier.size === 0) break;
+  }
+  const nodes = graph.nodes.filter((n) => visited.has(n.id));
+  const edges = graph.edges.filter((e) => visited.has(e.source) && visited.has(e.target));
+  return { nodes, edges };
+}
+function layerSummary(graph) {
+  const typeCounts = {};
+  const moduleCounts = {};
+  for (const n of graph.nodes) {
+    typeCounts[n.type] = (typeCounts[n.type] ?? 0) + 1;
+    const mod = n.module;
+    if (mod) moduleCounts[mod] = (moduleCounts[mod] ?? 0) + 1;
+  }
+  const edgeTypeCounts = {};
+  for (const e of graph.edges) {
+    edgeTypeCounts[e.type] = (edgeTypeCounts[e.type] ?? 0) + 1;
+  }
+  return {
+    total_nodes: graph.nodes.length,
+    total_edges: graph.edges.length,
+    by_type: typeCounts,
+    ...Object.keys(moduleCounts).length > 0 && { by_module: moduleCounts },
+    by_edge_type: edgeTypeCounts,
+    warnings: graph.warnings.length
+  };
+}
+function ok(text) {
+  return { content: [{ type: "text", text }] };
+}
+function okJson(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function err(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function handleGenerateGraph(args) {
+  const rootDir = process.cwd();
+  const layer = args.layer;
+  if (layer && !["ui", "api", "db"].includes(layer)) {
+    return err(`Invalid layer "${layer}". Must be one of: ui, api, db`);
+  }
+  const results = generateGraph(rootDir, layer);
+  if (results.length === 0) {
+    return err(
+      layer ? `No parser detected for the "${layer}" layer in this project.` : "No parsers detected for this project. Check that the project has the expected structure."
+    );
+  }
+  const summary = results.map((r) => {
+    const warnings = r.output.warnings.length;
+    return `  ${r.layer}: ${r.nodeCount} nodes, ${r.edgeCount} edges${warnings ? ` (${warnings} warnings)` : ""}`;
+  }).join("\n");
+  return ok(
+    `Graph generated successfully.
+
+Layers:
+${summary}
+
+Output: .launchsecure/graphs/
+
+Use read_graph with filters (search/type/module/node_id) to query.`
+  );
+}
+function runReadGraphQuery(rootDir, args) {
+  const layer = args.layer;
+  const search = args.search;
+  const type = args.type;
+  const module_ = args.module;
+  const nodeId = args.node_id;
+  const hops = args.hops ?? 1;
+  const minimal = args.minimal ?? false;
+  const hasFilter = !!(search || type || module_ || nodeId);
+  if (layer && !["ui", "api", "db"].includes(layer)) {
+    return { error: `Invalid layer "${layer}". Must be one of: ui, api, db` };
+  }
+  if (!layer) {
+    const graphs = readAllGraphs(rootDir);
+    const available = Object.keys(graphs);
+    if (available.length === 0) {
+      return { error: "No graphs found in .launchsecure/graphs/. Run generate_graph first." };
+    }
+    const summaries = {};
+    for (const l of available) {
+      summaries[l] = layerSummary(graphs[l]);
+    }
+    return {
+      hint: "No layer specified \u2014 returning per-layer summary. Call again with layer + filter to get nodes.",
+      available_layers: available,
+      summaries
+    };
+  }
+  const graph = readGraph(rootDir, layer);
+  if (!graph) {
+    return { error: `No ${layer} graph found at .launchsecure/graphs/${layer}.json. Run generate_graph first.` };
+  }
+  if (nodeId) {
+    const nb = neighborhood(graph, nodeId, hops);
+    if (!nb) {
+      return { error: `Node "${nodeId}" not found in ${layer} graph. Try read_graph with search="${nodeId}" to find similar nodes.` };
+    }
+    return {
+      layer,
+      center: nodeId,
+      hops,
+      node_count: nb.nodes.length,
+      edge_count: nb.edges.length,
+      nodes: minimal ? toMinimal(nb.nodes) : nb.nodes,
+      edges: nb.edges
+    };
+  }
+  if (!hasFilter) {
+    return {
+      hint: "No filter specified \u2014 returning summary only. Use search/type/module/node_id to retrieve nodes.",
+      layer,
+      summary: layerSummary(graph)
+    };
+  }
+  const matched = graph.nodes.filter((n) => {
+    if (search && !matchesSearch(n, search)) return false;
+    if (type && n.type !== type) return false;
+    if (module_ && n.module !== module_) return false;
+    return true;
+  });
+  const matchedIds = new Set(matched.map((n) => n.id));
+  const matchedEdges = graph.edges.filter((e) => matchedIds.has(e.source) && matchedIds.has(e.target));
+  if (matched.length === 0) {
+    return {
+      layer,
+      filter: { search, type, module: module_ },
+      matched: 0,
+      hint: "No nodes matched. Check spelling, or call read_graph without filter to see the summary and available types/modules."
+    };
+  }
+  return {
+    layer,
+    filter: { search, type, module: module_ },
+    matched: matched.length,
+    edge_count: matchedEdges.length,
+    nodes: minimal ? toMinimal(matched) : matched,
+    edges: matchedEdges
+  };
+}
+function handleReadGraph(args) {
+  const rootDir = process.cwd();
+  if (Array.isArray(args.queries)) {
+    const queries = args.queries;
+    if (queries.length === 0) {
+      return err("queries array is empty. Provide at least one query object.");
+    }
+    const results = queries.map((q, i) => ({ index: i, query: q, result: runReadGraphQuery(rootDir, q) }));
+    return okJson({ batch: true, count: results.length, results });
+  }
+  const result = runReadGraphQuery(rootDir, args);
+  return okJson(result);
+}
+function nodeToFilePath(rootDir, layer, nodeId) {
+  if (layer === "ui") return (0, import_node_path6.join)(rootDir, "src", nodeId);
+  if (layer === "api") return (0, import_node_path6.join)(rootDir, nodeId);
+  if (layer === "db") return (0, import_node_path6.join)(rootDir, "prisma", "schema.prisma");
+  return null;
+}
+function handleGrepNodes(args) {
+  const rootDir = process.cwd();
+  const pattern = args.pattern;
+  const layer = args.layer;
+  if (!pattern) return err("pattern is required");
+  if (!layer) return err("layer is required (ui, api, or db)");
+  if (!["ui", "api", "db"].includes(layer)) return err(`Invalid layer "${layer}". Must be one of: ui, api, db`);
+  const hasFilter = !!(args.search || args.type || args.module || args.node_id);
+  if (!hasFilter) {
+    return err(
+      "At least one filter (search/type/module/node_id) must be set. Without a filter, grep_nodes would scan the entire layer \u2014 use Grep directly for that."
+    );
+  }
+  let re;
+  try {
+    re = new RegExp(pattern, args.case_insensitive ? "i" : "");
+  } catch (e) {
+    return err(`Invalid regex: ${e.message}`);
+  }
+  const queryResult = runReadGraphQuery(rootDir, {
+    layer,
+    search: args.search,
+    type: args.type,
+    module: args.module,
+    node_id: args.node_id,
+    hops: args.hops,
+    minimal: true
+  });
+  if (queryResult.error) return err(queryResult.error);
+  const nodes = queryResult.nodes ?? [];
+  if (nodes.length === 0) {
+    return okJson({
+      pattern,
+      filter: { layer, search: args.search, type: args.type, module: args.module, node_id: args.node_id },
+      files_searched: 0,
+      total_matches: 0,
+      matches: []
+    });
+  }
+  const maxFiles = args.max_files ?? 50;
+  if (nodes.length > maxFiles) {
+    return err(
+      `Filter matched ${nodes.length} nodes (max_files: ${maxFiles}). Narrow the filter (add type/module) or pass max_files to override.`
+    );
+  }
+  const filePaths = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const fp = nodeToFilePath(rootDir, layer, node.id);
+    if (fp && !filePaths.has(fp)) filePaths.set(fp, node.id);
+  }
+  const contextLines = args.context ?? 2;
+  const maxMatches = args.max_matches ?? 50;
+  const matches = [];
+  let totalMatches = 0;
+  let filesSearched = 0;
+  let truncated = false;
+  for (const [filePath, nodeId] of filePaths) {
+    if (!(0, import_node_fs6.existsSync)(filePath)) continue;
+    filesSearched++;
+    let content;
+    try {
+      content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) {
+        totalMatches++;
+        const match = {
+          file: nodeId,
+          line: i + 1,
+          text: lines[i]
+        };
+        if (contextLines > 0) {
+          match.context = {
+            before: lines.slice(Math.max(0, i - contextLines), i),
+            after: lines.slice(i + 1, i + 1 + contextLines)
+          };
+        }
+        matches.push(match);
+        if (matches.length >= maxMatches) {
+          truncated = true;
+          break;
+        }
+      }
+    }
+    if (truncated) break;
+  }
+  return okJson({
+    pattern,
+    filter: { layer, search: args.search, type: args.type, module: args.module, node_id: args.node_id, hops: args.hops },
+    files_searched: filesSearched,
+    total_matches: totalMatches,
+    matches,
+    truncated
+  });
+}
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + "\n");
+}
+function respond(id, result) {
+  send({ jsonrpc: "2.0", id, result });
+}
+function respondError(id, code, message) {
+  send({ jsonrpc: "2.0", id, error: { code, message } });
+}
+function handleMessage(msg) {
+  const method = msg.method;
+  const id = msg.id;
+  if (method === "initialize") {
+    respond(id ?? null, {
+      protocolVersion: "2025-03-26",
+      capabilities: { tools: {} },
+      serverInfo: SERVER_INFO
+    });
+    return;
+  }
+  if (method === "notifications/initialized") {
+    return;
+  }
+  if (method === "tools/list") {
+    respond(id ?? null, { tools: TOOLS });
+    return;
+  }
+  if (method === "tools/call") {
+    const params = msg.params;
+    const toolName = params.name;
+    const args = params.arguments ?? {};
+    if (toolName === "generate_graph") {
+      respond(id ?? null, handleGenerateGraph(args));
+      return;
+    }
+    if (toolName === "read_graph") {
+      respond(id ?? null, handleReadGraph(args));
+      return;
+    }
+    if (toolName === "grep_nodes") {
+      respond(id ?? null, handleGrepNodes(args));
+      return;
+    }
+    respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
+    return;
+  }
+  if (method === "ping") {
+    respond(id ?? null, {});
+    return;
+  }
+  if (id !== void 0 && id !== null) {
+    respondError(id, -32601, `Method not found: ${method}`);
+  }
+}
+function startGraphMcpServer() {
+  process.stdin.setEncoding("utf-8");
+  let buffer = "";
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        handleMessage(JSON.parse(trimmed));
+      } catch (err2) {
+        process.stderr.write(`[launchsecure-graph] Parse error: ${err2}
+`);
+      }
+    }
+  });
+  process.stdin.on("end", () => {
+    process.exit(0);
+  });
+  process.stderr.write(`[launchsecure-graph] MCP server started (cwd: ${process.cwd()})
+`);
+}
+
+// src/server/graph-mcp-entry.ts
+startGraphMcpServer();