@launchsecure/launch-kit 0.0.2 → 0.0.4

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

@@ -1,22 +1,111 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
-// 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/lockfile.ts
+function lockDir() {
+  return (0, import_node_path.join)((0, import_node_os.homedir)(), ".launchsecure");
+}
+function lockPath() {
+  return (0, import_node_path.join)(lockDir(), "launch-chart.lock");
+}
+function readLock() {
+  const p = lockPath();
+  if (!(0, import_node_fs.existsSync)(p)) return null;
+  try {
+    const data = JSON.parse((0, import_node_fs.readFileSync)(p, "utf-8"));
+    if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getListenerPid(port) {
+  try {
+    const out = (0, import_node_child_process.execFileSync)("lsof", ["-nP", "-iTCP:" + port, "-sTCP:LISTEN", "-t"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 500
+    }).trim();
+    if (!out) return null;
+    const pid = parseInt(out.split("\n")[0], 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function getLiveLock() {
+  const lock = readLock();
+  if (!lock) return null;
+  const listenerPid = getListenerPid(lock.port);
+  const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
+  if (!live) {
+    try {
+      (0, import_node_fs.unlinkSync)(lockPath());
+    } catch {
+    }
+    return null;
+  }
+  return lock;
+}
+function writeLock(data) {
+  (0, import_node_fs.mkdirSync)(lockDir(), { recursive: true });
+  (0, import_node_fs.writeFileSync)(lockPath(), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function clearLock() {
+  try {
+    (0, import_node_fs.unlinkSync)(lockPath());
+  } catch {
+  }
+}
+var import_node_child_process, import_node_fs, import_node_os, import_node_path;
+var init_lockfile = __esm({
+  "src/server/lockfile.ts"() {
+    "use strict";
+    import_node_child_process = require("node:child_process");
+    import_node_fs = require("node:fs");
+    import_node_os = require("node:os");
+    import_node_path = 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");
@@ -25,8 +114,8 @@ function getTs() {
 }
 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 content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path2.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,
@@ -45,6 +134,8 @@ function parseFile(absPath) {
   const reExports = [];
   const jsxElements = /* @__PURE__ */ new Set();
   const navigations = [];
+  const fetchCalls = [];
+  const includeConcat = process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1";
   function addExport(name2, kind) {
     if (!exportsSet.has(name2)) {
       exportsSet.add(name2);
@@ -67,6 +158,33 @@ function parseFile(absPath) {
     }
     return null;
   }
+  function looksLikeUrl(s) {
+    return s.startsWith("/") || /^(https?:)?\/\//i.test(s);
+  }
+  function templateStartsWithSlash(expr) {
+    const head = expr.head.text;
+    return head.startsWith("/");
+  }
+  function extractUrlFromFetchArg(arg) {
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+      if (!looksLikeUrl(arg.text)) return null;
+      return { url: arg.text, isTemplate: false };
+    }
+    if (ts.isTemplateExpression(arg)) {
+      if (!templateStartsWithSlash(arg)) return null;
+      return { url: arg.getText(sourceFile), isTemplate: true };
+    }
+    if (includeConcat && ts.isBinaryExpression(arg) && arg.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      let leftmost = arg;
+      while (ts.isBinaryExpression(leftmost) && leftmost.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+        leftmost = leftmost.left;
+      }
+      if ((ts.isStringLiteral(leftmost) || ts.isNoSubstitutionTemplateLiteral(leftmost)) && leftmost.text.startsWith("/")) {
+        return { url: arg.getText(sourceFile), isTemplate: false, isConcat: true };
+      }
+    }
+    return null;
+  }
   function visit(node) {
     if (ts.isImportDeclaration(node)) {
       const moduleSpec = node.moduleSpecifier;
@@ -90,6 +208,8 @@ function parseFile(absPath) {
         }
         if (names.length > 0 || isTypeOnly) {
           imports.push({ names, specifier, isTypeOnly, typeNames });
+        } else if (!clause) {
+          imports.push({ names: [], specifier, isTypeOnly: false, typeNames: /* @__PURE__ */ new Set() });
         }
       }
     }
@@ -103,6 +223,19 @@ function parseFile(absPath) {
             reExports.push({ name: exportedName, from: fromSpec });
           }
         }
+      } else if (!node.exportClause && fromSpec) {
+        reExports.push({ name: "*", from: fromSpec, isWildcard: true });
+      }
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const arg = node.arguments[0];
+      if (arg && ts.isStringLiteral(arg)) {
+        imports.push({
+          names: [],
+          specifier: arg.text,
+          isTypeOnly: false,
+          typeNames: /* @__PURE__ */ new Set()
+        });
       }
     }
     if (ts.isExportAssignment(node) && !node.isExportEquals) {
@@ -164,6 +297,36 @@ function parseFile(absPath) {
         }
       }
     }
+    if (ts.isCallExpression(node) && node.arguments.length > 0) {
+      const expr = node.expression;
+      const firstArg = node.arguments[0];
+      if (ts.isIdentifier(expr) && expr.text === "fetch") {
+        const extracted = extractUrlFromFetchArg(firstArg);
+        if (extracted) {
+          fetchCalls.push({
+            url: extracted.url,
+            isTemplate: extracted.isTemplate,
+            ...extracted.isConcat ? { isConcat: true } : {},
+            kind: "fetch"
+          });
+        }
+      }
+      if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.name)) {
+        const methodName = expr.name.text;
+        if (HTTP_METHODS.has(methodName)) {
+          const extracted = extractUrlFromFetchArg(firstArg);
+          if (extracted) {
+            fetchCalls.push({
+              method: methodName.toUpperCase(),
+              url: extracted.url,
+              isTemplate: extracted.isTemplate,
+              ...extracted.isConcat ? { isConcat: true } : {},
+              kind: "client-method"
+            });
+          }
+        }
+      }
+    }
     if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
       const tagName = node.tagName;
       if (ts.isIdentifier(tagName) && tagName.text === "Link") {
@@ -213,24 +376,14 @@ function parseFile(absPath) {
     imports,
     reExports,
     jsxElements,
-    navigations
+    navigations,
+    fetchCalls
   };
 }
-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 content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path2.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 = [];
@@ -259,8 +412,8 @@ function extractDbCalls(absPath) {
 }
 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 content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  const ext = (0, import_node_path2.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();
@@ -276,55 +429,125 @@ function extractAuthWrappers(absPath) {
   visit(sourceFile);
   return wrappers;
 }
+var import_node_fs2, import_node_path2, tsModule, HTTP_METHODS, MUTATION_METHODS;
+var init_ast_helpers = __esm({
+  "src/server/graph/core/ast-helpers.ts"() {
+    "use strict";
+    import_node_fs2 = require("node:fs");
+    import_node_path2 = require("node:path");
+    HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
+    MUTATION_METHODS = /* @__PURE__ */ new Set([
+      "create",
+      "createMany",
+      "createManyAndReturn",
+      "update",
+      "updateMany",
+      "updateManyAndReturn",
+      "upsert",
+      "delete",
+      "deleteMany"
+    ]);
+  }
+});
 
 // 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 (!(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(...walk(full, exts));
-    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
+    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
       results.push(full);
     }
   }
   return results;
 }
+function walkWithIgnore(dir, exts, ignoreDirs) {
+  const results = [];
+  if (!(0, import_node_fs3.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (ignoreDirs.has(entry.name)) continue;
+      results.push(...walkWithIgnore((0, import_node_path3.join)(dir, entry.name), exts, ignoreDirs));
+    } else if (exts.includes((0, import_node_path3.extname)(entry.name))) {
+      results.push((0, import_node_path3.join)(dir, entry.name));
+    }
+  }
+  return results;
+}
 function toNodeId(srcDir, absPath) {
-  return (0, import_node_path2.relative)(srcDir, absPath).replace(/\\/g, "/");
+  return (0, import_node_path3.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;
+  const base = (0, import_node_path3.join)(srcDir, rel);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path3.join)(base, "index.ts"), (0, import_node_path3.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs3.existsSync)(c) && (0, import_node_fs3.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;
+  const base = (0, import_node_path3.join)((0, import_node_path3.dirname)(fromFile), specifier);
+  for (const c of [base, base + ".ts", base + ".tsx", (0, import_node_path3.join)(base, "index.ts"), (0, import_node_path3.join)(base, "index.tsx")]) {
+    if ((0, import_node_fs3.existsSync)(c) && (0, import_node_fs3.statSync)(c).isFile()) return c;
   }
   return null;
 }
+function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
+  const cached = memo.get(barrelAbsPath);
+  if (cached) return cached;
+  if (visiting.has(barrelAbsPath)) return /* @__PURE__ */ new Map();
+  visiting.add(barrelAbsPath);
+  const parsed = parsedByPath.get(barrelAbsPath);
+  const map = /* @__PURE__ */ new Map();
+  if (!parsed) {
+    visiting.delete(barrelAbsPath);
+    memo.set(barrelAbsPath, map);
+    return map;
+  }
+  for (const re of parsed.reExports) {
+    if (!re.from.startsWith(".")) continue;
+    const resolved = resolveRelativeImport(barrelAbsPath, re.from);
+    if (!resolved) continue;
+    if (re.isWildcard) {
+      const targetBn = (0, import_node_path3.basename)(resolved);
+      const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
+      if (targetIsBarrel) {
+        const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
+        for (const [name, target] of nested) {
+          if (!map.has(name)) map.set(name, target);
+        }
+      } else {
+        const targetParsed = parsedByPath.get(resolved);
+        if (targetParsed) {
+          for (const exp of targetParsed.exports) {
+            if (!map.has(exp)) map.set(exp, resolved);
+          }
+        }
+      }
+    } else {
+      if (!map.has(re.name)) map.set(re.name, resolved);
+    }
+  }
+  visiting.delete(barrelAbsPath);
+  memo.set(barrelAbsPath, map);
+  return map;
+}
 function buildAllBarrelMaps(srcDir, parsedByPath) {
   const barrels = /* @__PURE__ */ new Map();
+  const memo = /* @__PURE__ */ new Map();
   for (const [absPath, parsed] of parsedByPath) {
-    const bn = (0, import_node_path2.basename)(absPath);
+    const bn = (0, import_node_path3.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);
+    const map = resolveBarrelMap(absPath, parsedByPath, memo, /* @__PURE__ */ new Set());
+    if (map.size > 0) {
+      const barrelId = (0, import_node_path3.relative)(srcDir, (0, import_node_path3.dirname)(absPath)).replace(/\\/g, "/");
+      barrels.set(barrelId, map);
     }
-    if (map.size > 0) barrels.set(barrelId, map);
   }
   return barrels;
 }
@@ -381,7 +604,7 @@ function extractRoute(id) {
   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());
+  return (0, import_node_path3.basename)(absPath, (0, import_node_path3.extname)(absPath)).replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^(\w)/, (_, c) => c.toUpperCase());
 }
 function resolveTemplateLiteralRoute(template, routeToNodeId) {
   const parameterized = template.replace(/\$\{([^}]+)\}/g, (_, expr) => {
@@ -462,6 +685,105 @@ function matchRouteToPage(route, routeToNodeId) {
   if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
   return null;
 }
+function loadApiRoutes(rootDir) {
+  const apiJsonPath = (0, import_node_path3.join)(rootDir, ".launchsecure", "graphs", "api.json");
+  if (!(0, import_node_fs3.existsSync)(apiJsonPath)) return [];
+  try {
+    const parsed = JSON.parse((0, import_node_fs3.readFileSync)(apiJsonPath, "utf-8"));
+    const routes = [];
+    for (const n of parsed.nodes ?? []) {
+      const path3 = n.path;
+      if (!path3 || typeof path3 !== "string") continue;
+      routes.push({
+        path: path3,
+        nodeId: n.id,
+        segments: path3.split("/").filter(Boolean)
+      });
+    }
+    return routes;
+  } catch {
+    return [];
+  }
+}
+function buildApiPathMap(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    if (!map.has(r.path)) map.set(r.path, r.nodeId);
+  }
+  return map;
+}
+function normalizeFetchUrl(raw) {
+  let s = raw.replace(/^`|`$/g, "");
+  const qIdx = s.indexOf("?");
+  if (qIdx >= 0) s = s.slice(0, qIdx);
+  const hIdx = s.indexOf("#");
+  if (hIdx >= 0) s = s.slice(0, hIdx);
+  let hadInterpolation = false;
+  s = s.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    hadInterpolation = true;
+    const cleaned = expr.trim();
+    const last = cleaned.split(".").pop() ?? cleaned;
+    const name = last.replace(/[^\w]/g, "") || "param";
+    return ":" + name;
+  });
+  s = s.replace(/\/+/g, "/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return { path: s || "/", hadInterpolation };
+}
+function scoreApiRouteMatch(candidate, known) {
+  if (candidate.length !== known.length) return -1;
+  let score = 0;
+  for (let i = 0; i < candidate.length; i++) {
+    const a = candidate[i];
+    const b = known[i];
+    if (a === b) {
+      score += 3;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      score += 1;
+      continue;
+    }
+    return -1;
+  }
+  return score;
+}
+function resolveFetchCall(call, apiPathMap, apiRoutes) {
+  const raw = call.url;
+  if (/^(https?:)?\/\//i.test(raw)) {
+    return { kind: "external", normalizedUrl: raw };
+  }
+  if (call.isConcat) {
+    return { kind: "dynamic", normalizedUrl: raw };
+  }
+  const { path: path3, hadInterpolation } = normalizeFetchUrl(raw);
+  if (!path3.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path3 };
+  }
+  const segs = path3.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path3 };
+  }
+  const exact = apiPathMap.get(path3);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path3 };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path3 };
+  }
+  return { kind: "unresolved", normalizedUrl: path3 };
+}
 function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap, barrelMaps, routeToNodeId) {
   const edges = [];
   const flagged = [];
@@ -561,26 +883,26 @@ function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap,
   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"));
+  return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "src", "app")) && (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.ts")) || (0, import_node_fs3.existsSync)((0, import_node_path3.join)(rootDir, "next.config.js")) || (0, import_node_fs3.existsSync)((0, import_node_path3.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 srcDir = (0, import_node_path3.join)(rootDir, "src");
+  const appFiles = walk((0, import_node_path3.join)(srcDir, "app"), [".tsx", ".ts"]).filter(
+    (f) => (0, import_node_path3.basename)(f) !== "route.ts" && (0, import_node_path3.basename)(f) !== "route.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 clientFiles = walk((0, import_node_path3.join)(srcDir, "client"), [".tsx", ".ts"]);
+  const serverFiles = walk((0, import_node_path3.join)(srcDir, "server"), [".ts", ".tsx"]).filter(
+    (f) => (0, import_node_path3.basename)(f) !== "route.ts" && (0, import_node_path3.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 libFiles = walk((0, import_node_path3.join)(srcDir, "lib"), [".ts", ".tsx"]);
+  const configFiles = walk((0, import_node_path3.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 fileSet = allDiscovered.filter((f) => !(0, import_node_path3.basename)(f).startsWith("index."));
   const nodes = [];
   const nodeIdSet = /* @__PURE__ */ new Set();
   const nodeTypeMap = /* @__PURE__ */ new Map();
@@ -599,6 +921,7 @@ function generate(rootDir) {
   }
   const allEdges = [];
   const allFlagged = [];
+  const crossRefs = [];
   for (const absPath of fileSet) {
     const sourceId = toNodeId(srcDir, absPath);
     const parsed = parsedByPath.get(absPath);
@@ -615,6 +938,139 @@ function generate(rootDir) {
     allEdges.push(...edges);
     allFlagged.push(...flagged);
   }
+  const apiRoutes = loadApiRoutes(rootDir);
+  const apiPathMap = buildApiPathMap(apiRoutes);
+  const includeExternalFetches = process.env.LAUNCH_CHART_INCLUDE_EXTERNAL_FETCHES === "1";
+  const fetchSeen = /* @__PURE__ */ new Set();
+  let fetchResolvedCount = 0;
+  let fetchDynamicCount = 0;
+  let fetchUnresolvedCount = 0;
+  let fetchExternalCount = 0;
+  for (const absPath of fileSet) {
+    const sourceId = toNodeId(srcDir, absPath);
+    const parsed = parsedByPath.get(absPath);
+    if (parsed.fetchCalls.length === 0) continue;
+    for (const call of parsed.fetchCalls) {
+      const result = resolveFetchCall(call, apiPathMap, apiRoutes);
+      const methodTag = call.method ?? (call.kind === "fetch" ? "GET?" : "?");
+      if (result.kind === "resolved" && result.nodeId) {
+        const key = `${sourceId}\u2192${result.nodeId}\u2192calls_api`;
+        if (fetchSeen.has(key)) continue;
+        fetchSeen.add(key);
+        crossRefs.push({
+          source: sourceId,
+          target: result.nodeId,
+          type: "calls_api",
+          layer: "api"
+        });
+        fetchResolvedCount++;
+        continue;
+      }
+      if (result.kind === "dynamic") {
+        fetchDynamicCount++;
+        allFlagged.push({
+          source: sourceId,
+          target: "DYNAMIC",
+          type: "calls_api",
+          label: call.isConcat ? `${methodTag} fetch with concat: ${call.url}` : `${methodTag} fetch with template: ${call.url}`,
+          confidence: call.isConcat ? "low" : "medium"
+        });
+        continue;
+      }
+      if (result.kind === "external") {
+        fetchExternalCount++;
+        if (!includeExternalFetches) continue;
+        allFlagged.push({
+          source: sourceId,
+          target: "EXTERNAL",
+          type: "calls_external",
+          label: `${methodTag} external fetch: ${call.url}`,
+          confidence: "high"
+        });
+        continue;
+      }
+      fetchUnresolvedCount++;
+      allFlagged.push({
+        source: sourceId,
+        target: "UNRESOLVED",
+        type: "calls_api",
+        label: `${methodTag} fetch to unknown path: ${result.normalizedUrl}`,
+        confidence: "medium"
+      });
+    }
+  }
+  const externalScanned = new Set(allDiscovered.map((f) => f.replace(/\\/g, "/")));
+  const IGNORE_DIRS = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".next",
+    "dist",
+    ".launchsecure",
+    ".git",
+    "src",
+    "coverage",
+    ".turbo",
+    "build",
+    "out",
+    ".vercel"
+  ]);
+  const externalCandidates = walkWithIgnore(rootDir, [".ts", ".tsx"], IGNORE_DIRS);
+  for (const absPath of externalCandidates) {
+    const normalized = absPath.replace(/\\/g, "/");
+    if (externalScanned.has(normalized)) continue;
+    let parsed;
+    try {
+      parsed = parseFile(absPath);
+    } catch {
+      continue;
+    }
+    const externalId = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const edgesFromThis = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const imp of parsed.imports) {
+      const { specifier, isTypeOnly, names } = imp;
+      let resolved = null;
+      if (specifier.startsWith("@/")) {
+        const relToSrc = specifier.slice(2);
+        const barrelMap = barrelMaps.get(relToSrc);
+        if (barrelMap && names.length > 0) {
+          for (const name of names) {
+            const targetAbs = barrelMap.get(name);
+            if (!targetAbs) continue;
+            const targetId2 = toNodeId(srcDir, targetAbs);
+            if (!nodeIdSet.has(targetId2)) continue;
+            const key2 = `${externalId}\u2192${targetId2}`;
+            if (seen.has(key2)) continue;
+            seen.add(key2);
+            edgesFromThis.push({ source: externalId, target: targetId2, type: "imports" });
+          }
+          continue;
+        }
+        resolved = resolveImport(srcDir, specifier);
+      } else if (specifier.startsWith(".")) {
+        resolved = resolveRelativeImport(absPath, specifier);
+      }
+      if (!resolved) continue;
+      const targetId = toNodeId(srcDir, resolved);
+      if (!nodeIdSet.has(targetId)) continue;
+      if (targetId.endsWith("/index.ts") || targetId.endsWith("/index.tsx")) continue;
+      const key = `${externalId}\u2192${targetId}\u2192${isTypeOnly ? "type" : "value"}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edgesFromThis.push({ source: externalId, target: targetId, type: "imports" });
+    }
+    if (edgesFromThis.length === 0) continue;
+    nodes.push({
+      id: externalId,
+      type: "external",
+      name: parsed.name || nameFromFilename(absPath),
+      route: null,
+      module: "external",
+      exports: parsed.exports
+    });
+    nodeIdSet.add(externalId);
+    nodeTypeMap.set(externalId, "external");
+    allEdges.push(...edgesFromThis);
+  }
   const flaggedSet = /* @__PURE__ */ new Set();
   const dedupedFlagged = allFlagged.filter((f) => {
     const key = `${f.source}\u2192${f.target}\u2192${f.label}`;
@@ -646,6 +1102,7 @@ function generate(rootDir) {
     total_configs: byType("config"),
     total_utils: byType("util"),
     total_libs: byType("lib"),
+    total_external: byType("external"),
     total_edges: allEdges.length,
     total_flagged: dedupedFlagged.length
   };
@@ -657,11 +1114,20 @@ function generate(rootDir) {
       layer: "ui",
       parser: "react-nextjs-ast",
       ...stats,
+      api_call_detection: {
+        includeExternalFetches,
+        includeConcatFetches: process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1",
+        apiRoutesLoaded: apiRoutes.length,
+        resolved: fetchResolvedCount,
+        dynamic: fetchDynamicCount,
+        unresolved: fetchUnresolvedCount,
+        external: fetchExternalCount
+      },
       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: [],
+    cross_refs: crossRefs,
     contradictions: [],
     warnings: [],
     flagged_edges: dedupedFlagged,
@@ -676,22 +1142,29 @@ function generate(rootDir) {
     }
   };
 }
-var reactNextjsParser = {
-  id: "react-nextjs",
-  layer: "ui",
-  detect,
-  generate
-};
+var import_node_fs3, import_node_path3, RENDER_TYPES, reactNextjsParser;
+var init_react_nextjs = __esm({
+  "src/server/graph/parsers/ui/react-nextjs.ts"() {
+    "use strict";
+    import_node_fs3 = require("node:fs");
+    import_node_path3 = require("node:path");
+    init_ast_helpers();
+    RENDER_TYPES = /* @__PURE__ */ new Set(["component", "ui", "layout", "context"]);
+    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 (!(0, import_node_fs4.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+    const full = (0, import_node_path4.join)(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...walk2(full));
     } else if (entry.name === "route.ts" || entry.name === "route.tsx") {
@@ -701,7 +1174,7 @@ function walk2(dir) {
   return results;
 }
 function filePathToRoute(apiDir, absPath) {
-  let route = "/" + (0, import_node_path3.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
+  let route = "/" + (0, import_node_path4.relative)(apiDir, absPath).replace(/\\/g, "/").replace(/\/route\.tsx?$/, "");
   route = route.replace(/\[([^\]]+)\]/g, ":$1");
   route = route.replace(/\/+/g, "/");
   if (route === "/") return "/api";
@@ -712,10 +1185,10 @@ function camelToPascal(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"));
+  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "src", "app", "api"));
 }
 function generate2(rootDir) {
-  const apiDir = (0, import_node_path3.join)(rootDir, "src", "app", "api");
+  const apiDir = (0, import_node_path4.join)(rootDir, "src", "app", "api");
   const routeFiles = walk2(apiDir);
   const nodes = [];
   const edges = [];
@@ -730,10 +1203,10 @@ function generate2(rootDir) {
     const authWrappers = extractAuthWrappers(absPath);
     const methods = [];
     for (const exp of parsed.exports) {
-      if (HTTP_METHODS.has(exp)) methods.push(exp);
+      if (HTTP_METHODS2.has(exp)) methods.push(exp);
     }
     const routePath = filePathToRoute(apiDir, absPath);
-    const relPath = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const relPath = (0, import_node_path4.relative)(rootDir, absPath).replace(/\\/g, "/");
     const mutations = dbCalls.filter((c) => c.isMutation);
     const reads = dbCalls.filter((c) => !c.isMutation);
     const mutates = mutations.length > 0;
@@ -800,7 +1273,7 @@ function generate2(rootDir) {
     flagged_edges: [],
     patterns: {
       total_endpoints: nodes.length,
-      methods_breakdown: [...HTTP_METHODS].reduce((acc, m) => {
+      methods_breakdown: [...HTTP_METHODS2].reduce((acc, m) => {
         acc[m] = nodes.filter((n) => n.methods.includes(m)).length;
         return acc;
       }, {}),
@@ -810,16 +1283,24 @@ function generate2(rootDir) {
     }
   };
 }
-var nextjsRoutesParser = {
-  id: "nextjs-routes",
-  layer: "api",
-  detect: detect2,
-  generate: generate2
-};
+var import_node_fs4, import_node_path4, HTTP_METHODS2, nextjsRoutesParser;
+var init_nextjs_routes = __esm({
+  "src/server/graph/parsers/api/nextjs-routes.ts"() {
+    "use strict";
+    import_node_fs4 = require("node:fs");
+    import_node_path4 = require("node:path");
+    init_ast_helpers();
+    HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+    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 = [];
@@ -910,11 +1391,11 @@ function parseEnums(content) {
   return nodes;
 }
 function detect3(rootDir) {
-  return (0, import_node_fs4.existsSync)((0, import_node_path4.join)(rootDir, "prisma", "schema.prisma"));
+  return (0, import_node_fs5.existsSync)((0, import_node_path5.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 schemaPath = (0, import_node_path5.join)(rootDir, "prisma", "schema.prisma");
+  const content = (0, import_node_fs5.readFileSync)(schemaPath, "utf-8");
   const { nodes: modelNodes, relations } = parseModels(content);
   const enumNodes = parseEnums(content);
   const allNodes = [...modelNodes, ...enumNodes];
@@ -963,19 +1444,22 @@ function generate3(rootDir) {
     }
   };
 }
-var prismaSchemaParser = {
-  id: "prisma-schema",
-  layer: "db",
-  detect: detect3,
-  generate: generate3
-};
+var import_node_fs5, import_node_path5, prismaSchemaParser;
+var init_prisma_schema = __esm({
+  "src/server/graph/parsers/db/prisma-schema.ts"() {
+    "use strict";
+    import_node_fs5 = require("node:fs");
+    import_node_path5 = require("node:path");
+    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);
 }
@@ -992,37 +1476,49 @@ function generateLayer(rootDir, layer) {
   };
 }
 function generateAll(rootDir) {
-  const layers = ["ui", "api", "db"];
+  const layers = ["api", "db", "ui"];
   const results = [];
   for (const layer of layers) {
     const result = generateLayer(rootDir, layer);
     if (result) results.push(result);
   }
-  return results;
+  const byLayer = new Map(results.map((r) => [r.layer, r]));
+  return ["ui", "api", "db"].map((l) => byLayer.get(l)).filter((r) => !!r);
 }
+var ALL_PARSERS;
+var init_graph_builder = __esm({
+  "src/server/graph/core/graph-builder.ts"() {
+    "use strict";
+    init_react_nextjs();
+    init_nextjs_routes();
+    init_prisma_schema();
+    ALL_PARSERS = [
+      reactNextjsParser,
+      nextjsRoutesParser,
+      prismaSchemaParser
+    ];
+  }
+});
 
 // 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);
+  return (0, import_node_path6.join)(rootDir, GRAPHS_DIR);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path5.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path6.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);
+  if (!(0, import_node_fs6.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs6.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 content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
   const graph = JSON.parse(content);
   graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
   return graph;
@@ -1037,139 +1533,287 @@ function readAllGraphs(rootDir) {
 }
 function generateGraph(rootDir, layer) {
   const dir = graphsDir(rootDir);
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs6.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");
+    (0, import_node_fs6.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
     invalidateCache(filePath);
   }
   return results;
 }
+var import_node_fs6, import_node_path6, GRAPHS_DIR, LAYERS, graphCache;
+var init_graph = __esm({
+  "src/server/graph/index.ts"() {
+    "use strict";
+    import_node_fs6 = require("node:fs");
+    import_node_path6 = require("node:path");
+    init_graph_builder();
+    GRAPHS_DIR = ".launchsecure/graphs";
+    LAYERS = ["ui", "api", "db"];
+    graphCache = /* @__PURE__ */ new Map();
+  }
+});
 
-// 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."
-        }
+// src/server/chart-serve.ts
+var chart_serve_exports = {};
+__export(chart_serve_exports, {
+  runServeCli: () => runServeCli,
+  startChartServer: () => startChartServer
+});
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 8; i++) {
+    const graphsDir2 = import_node_path7.default.join(dir, ".launchsecure", "graphs");
+    if (import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "ui.json")) || import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "api.json")) || import_node_fs7.default.existsSync(import_node_path7.default.join(graphsDir2, "db.json"))) return dir;
+    const parent = import_node_path7.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  dir = startDir;
+  for (let i = 0; i < 8; i++) {
+    if (import_node_fs7.default.existsSync(import_node_path7.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path7.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir;
+}
+function buildMergedGraph(projectRoot) {
+  let graphs = readAllGraphs(projectRoot);
+  if (!graphs.ui && !graphs.api && !graphs.db) {
+    generateGraph(projectRoot);
+    graphs = readAllGraphs(projectRoot);
+  }
+  const nodes = [];
+  const rawLinks = [];
+  const LAYERS2 = ["ui", "api", "db"];
+  for (const layer of LAYERS2) {
+    const g = graphs[layer];
+    if (!g) continue;
+    for (const n of g.nodes) {
+      nodes.push({
+        id: `${layer}:${n.id}`,
+        name: n.name,
+        type: n.type,
+        layer,
+        module: n.module ?? null,
+        path: n.path ?? n.id
+      });
+    }
+    for (const e of g.edges) {
+      rawLinks.push({ source: `${layer}:${e.source}`, target: `${layer}:${e.target}`, type: e.type, layer, cross: false });
+    }
+    for (const c of g.cross_refs ?? []) {
+      rawLinks.push({ source: `${layer}:${c.source}`, target: `${c.layer}:${c.target}`, type: c.type, layer, cross: true });
+    }
+  }
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const links = rawLinks.filter((l) => nodeIds.has(l.source) && nodeIds.has(l.target));
+  return {
+    nodes,
+    links,
+    stats: {
+      nodes: nodes.length,
+      links: links.length,
+      byLayer: {
+        ui: graphs.ui ? graphs.ui.nodes.length : 0,
+        api: graphs.api ? graphs.api.nodes.length : 0,
+        db: graphs.db ? graphs.db.nodes.length : 0
       }
     }
-  },
-  {
-    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" }
-            }
-          }
+  };
+}
+function serveStatic(res, filePath) {
+  if (!import_node_fs7.default.existsSync(filePath) || !import_node_fs7.default.statSync(filePath).isFile()) return false;
+  const ext = import_node_path7.default.extname(filePath).toLowerCase();
+  const mime = MIME_TYPES[ext] ?? "application/octet-stream";
+  res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
+  import_node_fs7.default.createReadStream(filePath).pipe(res);
+  return true;
+}
+function serveIndex(res, clientDir) {
+  const indexPath = import_node_path7.default.join(clientDir, "index.html");
+  if (!import_node_fs7.default.existsSync(indexPath)) {
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end(`LaunchChart client bundle not found at ${clientDir}. Run 'npm run build:chart-client'.`);
+    return;
+  }
+  serveStatic(res, indexPath);
+}
+function tryListen(server, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (err2) => {
+      server.off("listening", onListening);
+      reject(err2);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve(port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
+}
+async function bindWithFallback(server, startPort) {
+  let lastErr = null;
+  for (let i = 0; i < MAX_PORT_SCAN; i++) {
+    const port = startPort + i;
+    try {
+      return await tryListen(server, port);
+    } catch (err2) {
+      const code = err2.code;
+      if (code === "EADDRINUSE") {
+        lastErr = err2;
+        continue;
+      }
+      throw err2;
+    }
+  }
+  throw lastErr ?? new Error("Failed to bind any port");
+}
+async function startChartServer(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(cwd);
+  const existing = getLiveLock();
+  if (existing) {
+    if (!opts.quiet) {
+      process.stderr.write(
+        `[launch-chart] already running (pid ${existing.pid}) at ${existing.url}
+`
+      );
+    }
+    return { port: existing.port, url: existing.url };
+  }
+  const clientDir = opts.clientDir ?? import_node_path7.default.join(__dirname, "..", "chart-client");
+  const server = import_node_http.default.createServer((req, res) => {
+    try {
+      const url2 = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      if (req.method === "GET" && url2.pathname === "/api/project-graph") {
+        const regenerate = url2.searchParams.get("regenerate") === "1";
+        if (regenerate) generateGraph(projectRoot);
+        const merged = buildMergedGraph(projectRoot);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          ...merged,
+          debug: { cwd, projectRoot }
+        }));
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/raw-graphs") {
+        const graphs = readAllGraphs(projectRoot);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ui: graphs.ui ?? null, api: graphs.api ?? null, db: graphs.db ?? null }));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/generate-graph") {
+        try {
+          generateGraph(projectRoot);
+          const graphs = readAllGraphs(projectRoot);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            ok: true,
+            ui: graphs.ui ?? null,
+            api: graphs.api ?? null,
+            db: graphs.db ?? null
+          }));
+        } catch (err2) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: String(err2) }));
         }
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, projectRoot }));
+        return;
       }
+      if (url2.pathname !== "/") {
+        const staticPath = import_node_path7.default.join(clientDir, url2.pathname);
+        if (serveStatic(res, staticPath)) return;
+      }
+      serveIndex(res, clientDir);
+    } catch (err2) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: String(err2) }));
     }
-  },
-  {
-    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"]
+  });
+  const port = await bindWithFallback(server, opts.port ?? DEFAULT_PORT);
+  const url = `http://localhost:${port}`;
+  writeLock({
+    pid: process.pid,
+    port,
+    cwd,
+    url,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const cleanup = () => {
+    clearLock();
+    server.close();
+  };
+  process.once("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.once("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.once("exit", cleanup);
+  if (!opts.quiet) {
+    process.stderr.write(`[launch-chart] serving ${url}
+`);
+    process.stderr.write(`[launch-chart] project root: ${projectRoot}
+`);
+  }
+  return { port, url };
+}
+function runServeCli(argv) {
+  let port;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--port" && argv[i + 1]) {
+      port = parseInt(argv[++i], 10);
+    } else if (argv[i].startsWith("--port=")) {
+      port = parseInt(argv[i].slice("--port=".length), 10);
     }
   }
-];
+  startChartServer({ port }).catch((err2) => {
+    process.stderr.write(`[launch-chart] failed to start: ${err2}
+`);
+    process.exit(1);
+  });
+}
+var import_node_http, import_node_fs7, import_node_path7, DEFAULT_PORT, MAX_PORT_SCAN, MIME_TYPES;
+var init_chart_serve = __esm({
+  "src/server/chart-serve.ts"() {
+    "use strict";
+    import_node_http = __toESM(require("node:http"));
+    import_node_fs7 = __toESM(require("node:fs"));
+    import_node_path7 = __toESM(require("node:path"));
+    init_graph();
+    init_lockfile();
+    DEFAULT_PORT = 52819;
+    MAX_PORT_SCAN = 20;
+    MIME_TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".png": "image/png",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2"
+    };
+  }
+});
+
+// src/server/graph-mcp.ts
+var graph_mcp_exports = {};
+__export(graph_mcp_exports, {
+  startGraphMcpServer: () => startGraphMcpServer
+});
 function matchesSearch(node, query) {
   const q = query.toLowerCase();
   if (node.id.toLowerCase().includes(q)) return true;
@@ -1181,30 +1825,88 @@ function matchesSearch(node, query) {
 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;
+    if (n.module != null) out.module = n.module;
+    if (n.route != null) out.route = n.route;
+    if (n.methods != null) out.methods = n.methods;
     return out;
   });
 }
-function neighborhood(graph, centerId, hops) {
+function toCompactNode(n) {
+  const out = { i: n.id, t: n.type, n: n.name };
+  if (n.module != null) out.m = n.module;
+  if (n.route != null) out.r = n.route;
+  if (n.methods != null) out.mt = n.methods;
+  if (n.exports != null) out.x = n.exports;
+  if (n.columns != null) out.c = n.columns;
+  for (const k of Object.keys(n)) {
+    if (!COMPACT_NODE_KNOWN_KEYS.has(k) && n[k] != null) out[k] = n[k];
+  }
+  return out;
+}
+function toCompactEdges(edges, idx) {
+  return edges.map((e) => {
+    const s = idx.get(e.source);
+    const d = idx.get(e.target);
+    const o = {
+      s: s ?? e.source,
+      d: d ?? e.target,
+      t: e.type
+    };
+    if (e.label != null) o.l = e.label;
+    return o;
+  });
+}
+function compactResult(raw) {
+  const nodes = raw.nodes;
+  if (!nodes) return raw;
+  const idx = /* @__PURE__ */ new Map();
+  nodes.forEach((n, i) => idx.set(n.id, i));
+  const compactNodes = nodes.map(toCompactNode);
+  const edges = raw.edges;
+  const compactEdges = edges ? toCompactEdges(edges, idx) : void 0;
+  const out = { _schema: COMPACT_SCHEMA };
+  for (const [k, v] of Object.entries(raw)) {
+    if (k === "nodes" || k === "edges") continue;
+    out[k] = v;
+  }
+  out.nodes = compactNodes;
+  if (compactEdges !== void 0) out.edges = compactEdges;
+  return out;
+}
+function neighborhood(graph, centerId, hops, layer, minimal) {
   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]);
+  let budgetExceeded = false;
+  let stoppedAtHop = 0;
   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);
     }
+    const projectedVisited = visited.size + next.size;
+    let projectedEdges = 0;
+    for (const e of graph.edges) {
+      const srcIn = visited.has(e.source) || next.has(e.source);
+      const dstIn = visited.has(e.target) || next.has(e.target);
+      if (srcIn && dstIn) projectedEdges++;
+    }
+    const perNode = minimal ? EST_CHARS_PER_NODE_MIN[layer] : EST_CHARS_PER_NODE_FULL[layer];
+    const projectedChars = projectedVisited * perNode + projectedEdges * EST_CHARS_PER_EDGE[layer];
+    if (projectedChars > NEIGHBORHOOD_BUDGET_CHARS) {
+      budgetExceeded = true;
+      break;
+    }
     for (const id of next) visited.add(id);
     frontier = next;
+    stoppedAtHop = h + 1;
     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 };
+  return { nodes, edges, budgetExceeded, stoppedAtHop };
 }
 function layerSummary(graph) {
   const typeCounts = {};
@@ -1263,14 +1965,16 @@ Output: .launchsecure/graphs/
 Use read_graph with filters (search/type/module/node_id) to query.`
   );
 }
-function runReadGraphQuery(rootDir, args) {
+function runReadGraphQueryRaw(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 layerIsDb = args.layer === "db";
+  const minimal = args.minimal ?? layerIsDb;
+  const includeEdges = args.include_edges;
   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` };
@@ -1296,19 +2000,26 @@ function runReadGraphQuery(rootDir, args) {
     return { error: `No ${layer} graph found at .launchsecure/graphs/${layer}.json. Run generate_graph first.` };
   }
   if (nodeId) {
-    const nb = neighborhood(graph, nodeId, hops);
+    const nb = neighborhood(graph, nodeId, hops, layer, minimal);
     if (!nb) {
       return { error: `Node "${nodeId}" not found in ${layer} graph. Try read_graph with search="${nodeId}" to find similar nodes.` };
     }
-    return {
+    const wantEdges2 = includeEdges ?? true;
+    const result2 = {
       layer,
       center: nodeId,
-      hops,
+      hops_requested: hops,
+      hops_traversed: nb.stoppedAtHop,
       node_count: nb.nodes.length,
       edge_count: nb.edges.length,
-      nodes: minimal ? toMinimal(nb.nodes) : nb.nodes,
-      edges: nb.edges
+      nodes: minimal ? toMinimal(nb.nodes) : nb.nodes
     };
+    if (wantEdges2) result2.edges = nb.edges;
+    if (nb.budgetExceeded) {
+      result2.budget_exceeded = true;
+      result2.hint = `Neighborhood truncated at hop ${nb.stoppedAtHop} (projected size exceeded budget). To explore further, call read_graph with node_id set to a specific neighbor from the returned nodes, or rerun with hops=${Math.max(1, nb.stoppedAtHop)} to confirm the partial view is what you wanted.`;
+    }
+    return result2;
   }
   if (!hasFilter) {
     return {
@@ -1333,14 +2044,24 @@ function runReadGraphQuery(rootDir, args) {
       hint: "No nodes matched. Check spelling, or call read_graph without filter to see the summary and available types/modules."
     };
   }
-  return {
+  const wantEdges = includeEdges ?? false;
+  const result = {
     layer,
     filter: { search, type, module: module_ },
     matched: matched.length,
     edge_count: matchedEdges.length,
-    nodes: minimal ? toMinimal(matched) : matched,
-    edges: matchedEdges
+    nodes: minimal ? toMinimal(matched) : matched
   };
+  if (wantEdges) {
+    result.edges = matchedEdges;
+  } else {
+    result.edges_hint = `${matchedEdges.length} edges between matched nodes omitted. Pass include_edges:true to retrieve them (only do this when you actually need edge data).`;
+  }
+  return result;
+}
+function runReadGraphQuery(rootDir, args) {
+  const raw = runReadGraphQueryRaw(rootDir, args);
+  return compactResult(raw);
 }
 function handleReadGraph(args) {
   const rootDir = process.cwd();
@@ -1349,16 +2070,57 @@ function handleReadGraph(args) {
     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 results = [];
+    let cumulativeChars = 0;
+    let budgetHit = false;
+    for (let i = 0; i < queries.length; i++) {
+      const q = queries[i];
+      if (budgetHit) {
+        results.push({
+          index: i,
+          query: q,
+          result: {
+            skipped: true,
+            reason: "batch_budget_exhausted",
+            hint: "Previous sub-results filled the batch budget. Re-run this query on its own."
+          }
+        });
+        continue;
+      }
+      const r = runReadGraphQuery(rootDir, q);
+      const entry = { index: i, query: q, result: r };
+      const entrySize = JSON.stringify(entry, null, 2).length;
+      if (cumulativeChars + entrySize > BATCH_BUDGET_CHARS && results.length > 0) {
+        budgetHit = true;
+        results.push({
+          index: i,
+          query: q,
+          result: {
+            skipped: true,
+            reason: "batch_budget_exhausted",
+            hint: "This sub-query would push the batch over its size budget. Re-run it on its own."
+          }
+        });
+      } else {
+        results.push(entry);
+        cumulativeChars += entrySize;
+      }
+    }
+    return okJson({
+      batch: true,
+      count: results.length,
+      cumulative_chars: cumulativeChars,
+      budget_hit: budgetHit,
+      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");
+  if (layer === "ui") return (0, import_node_path8.join)(rootDir, "src", nodeId);
+  if (layer === "api") return (0, import_node_path8.join)(rootDir, nodeId);
+  if (layer === "db") return (0, import_node_path8.join)(rootDir, "prisma", "schema.prisma");
   return null;
 }
 function handleGrepNodes(args) {
@@ -1380,7 +2142,7 @@ function handleGrepNodes(args) {
   } catch (e) {
     return err(`Invalid regex: ${e.message}`);
   }
-  const queryResult = runReadGraphQuery(rootDir, {
+  const queryResult = runReadGraphQueryRaw(rootDir, {
     layer,
     search: args.search,
     type: args.type,
@@ -1418,11 +2180,11 @@ function handleGrepNodes(args) {
   let filesSearched = 0;
   let truncated = false;
   for (const [filePath, nodeId] of filePaths) {
-    if (!(0, import_node_fs6.existsSync)(filePath)) continue;
+    if (!(0, import_node_fs8.existsSync)(filePath)) continue;
     filesSearched++;
     let content;
     try {
-      content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+      content = (0, import_node_fs8.readFileSync)(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -1459,6 +2221,23 @@ function handleGrepNodes(args) {
     truncated
   });
 }
+function handleGetGraphUiUrl() {
+  const lock = getLiveLock();
+  if (!lock) {
+    return okJson({
+      running: false,
+      hint: "No launch-chart UI server is currently running. Start one with `launch-chart serve`, or set LAUNCH_CHART_AUTOSERVE=1 in your MCP config to auto-start it alongside the MCP server."
+    });
+  }
+  return okJson({
+    running: true,
+    url: lock.url,
+    port: lock.port,
+    pid: lock.pid,
+    cwd: lock.cwd,
+    startedAt: lock.startedAt
+  });
+}
 function send(msg) {
   process.stdout.write(JSON.stringify(msg) + "\n");
 }
@@ -1502,6 +2281,10 @@ function handleMessage(msg) {
       respond(id ?? null, handleGrepNodes(args));
       return;
     }
+    if (toolName === "get_graph_ui_url") {
+      respond(id ?? null, handleGetGraphUiUrl());
+      return;
+    }
     respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
     return;
   }
@@ -1537,6 +2320,248 @@ function startGraphMcpServer() {
   process.stderr.write(`[launchsecure-graph] MCP server started (cwd: ${process.cwd()})
 `);
 }
+var import_node_fs8, import_node_path8, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, EST_CHARS_PER_NODE_FULL, EST_CHARS_PER_NODE_MIN, EST_CHARS_PER_EDGE, NEIGHBORHOOD_BUDGET_CHARS, BATCH_BUDGET_CHARS;
+var init_graph_mcp = __esm({
+  "src/server/graph-mcp.ts"() {
+    "use strict";
+    import_node_fs8 = require("node:fs");
+    import_node_path8 = require("node:path");
+    init_graph();
+    init_lockfile();
+    SERVER_INFO = {
+      name: "launchsecure-graph",
+      version: "0.0.1"
+    };
+    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- include_edges: return the actual edge list. Default: TRUE for neighborhood queries (node_id), FALSE for filter queries (search/type/module). Filter responses always include `edge_count`; only pass include_edges:true when you actually need to inspect individual edges (e.g. "which components render X"). This default cuts typical filter responses in half.\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.\n\nWIRE FORMAT (compact): responses that include nodes/edges use short keys and edge-by-index refs to cut payload ~40-60%. Every such response carries a `_schema` legend. Quick reference:\n  nodes[]: { i: id, t: type, n: name, m: module, r: route, mt: methods, x: exports, c: columns }\n  edges[]: { s: source_node_index, d: target_node_index, t: type, l: label }\nedges.s / edges.d are 0-based indices into THIS response\'s nodes array. If a referenced node is not in the response (boundary case), s/d may instead contain the full node id string \u2014 always check the type.\n\nBUDGET GUARDS:\n- Neighborhood queries stop expanding when the projected response exceeds budget. The response then contains `budget_exceeded: true` plus `hops_traversed < hops_requested`. When this happens, drill into a specific neighbor with another node_id call rather than retrying with larger hops \u2014 it will just truncate again.\n- Batch mode caps total response size. Once the budget is hit, later queries return `{skipped: true, reason: "batch_budget_exhausted"}` and you must re-run them individually.',
+        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, except db-layer filter queries default to true (db table nodes carry heavy `columns` arrays). Pass minimal:false on a db filter query if you want columns."
+            },
+            include_edges: {
+              type: "boolean",
+              description: "Include the edge list in the response. Default TRUE for neighborhood queries (node_id), FALSE for filter queries. Filter responses always include edge_count. Only set true on filter queries when you actually need edge data."
+            },
+            queries: {
+              type: "array",
+              description: "Batch mode \u2014 array of query objects to run in a single call. Each uses the same param schema. When set, top-level params are ignored. Subject to an aggregate size budget \u2014 later queries may return a skipped stub.",
+              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" },
+                  include_edges: { 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"]
+        }
+      },
+      {
+        name: "get_graph_ui_url",
+        description: 'Return the URL of a running launch-chart UI server if one exists. The UI is a visual, interactive view of the merged UI+API+DB project graph served by `launch-chart serve` (or auto-started via LAUNCH_CHART_AUTOSERVE=1). \n\nReturns: { running: boolean, url?: string, port?: number, pid?: number, startedAt?: string, cwd?: string }. If running is false, no server is currently live \u2014 suggest the user run `launch-chart serve` to start one. \n\nUse this when the user asks "open the graph", "show me the project graph UI", "where\'s the chart", etc.',
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      }
+    ];
+    COMPACT_SCHEMA = {
+      nodes: {
+        i: "id",
+        t: "type",
+        n: "name",
+        m: "module",
+        r: "route",
+        mt: "methods",
+        x: "exports",
+        c: "columns"
+      },
+      edges: {
+        s: "source_node_index",
+        d: "target_node_index",
+        t: "type",
+        l: "label"
+      },
+      note: "edges.s/d are 0-based indices into this response's nodes array. If a referenced node is outside the response (boundary case), s/d may contain the full node id string instead of an index."
+    };
+    COMPACT_NODE_KNOWN_KEYS = /* @__PURE__ */ new Set([
+      "id",
+      "type",
+      "name",
+      "module",
+      "route",
+      "methods",
+      "exports",
+      "columns"
+    ]);
+    EST_CHARS_PER_NODE_FULL = {
+      ui: 300,
+      api: 300,
+      db: 3500
+    };
+    EST_CHARS_PER_NODE_MIN = {
+      ui: 150,
+      api: 200,
+      db: 120
+    };
+    EST_CHARS_PER_EDGE = {
+      ui: 65,
+      api: 65,
+      db: 65
+    };
+    NEIGHBORHOOD_BUDGET_CHARS = 55e3;
+    BATCH_BUDGET_CHARS = 6e4;
+  }
+});
 
 // src/server/graph-mcp-entry.ts
-startGraphMcpServer();
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs9 = require("node:fs");
+var import_node_path9 = __toESM(require("node:path"));
+var import_node_os2 = require("node:os");
+var import_node_fs10 = require("node:fs");
+init_lockfile();
+function logStderr(msg) {
+  process.stderr.write(`[launch-chart] ${msg}
+`);
+}
+function maybeAutoServe() {
+  if (process.env.LAUNCH_CHART_AUTOSERVE !== "1") return;
+  const existing = getLiveLock();
+  if (existing) {
+    logStderr(`autoserve: reusing existing server at ${existing.url}`);
+    return;
+  }
+  try {
+    const logDir = import_node_path9.default.join((0, import_node_os2.homedir)(), ".launchsecure");
+    (0, import_node_fs10.mkdirSync)(logDir, { recursive: true });
+    const logPath = import_node_path9.default.join(logDir, "launch-chart.log");
+    const out = (0, import_node_fs9.openSync)(logPath, "a");
+    const err2 = (0, import_node_fs9.openSync)(logPath, "a");
+    const entryPath = process.argv[1];
+    const child = (0, import_node_child_process2.spawn)(process.execPath, [entryPath, "serve"], {
+      detached: true,
+      stdio: ["ignore", out, err2],
+      env: { ...process.env, LAUNCH_CHART_AUTOSERVE: "" }
+    });
+    child.unref();
+    logStderr(`autoserve: spawned detached serve process (pid ${child.pid}, log: ${logPath})`);
+  } catch (err2) {
+    logStderr(`autoserve: failed to spawn \u2014 ${err2}`);
+  }
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const subcommand = argv[0];
+  if (subcommand === "serve") {
+    const { runServeCli: runServeCli2 } = await Promise.resolve().then(() => (init_chart_serve(), chart_serve_exports));
+    runServeCli2(argv.slice(1));
+    return;
+  }
+  maybeAutoServe();
+  const { startGraphMcpServer: startGraphMcpServer2 } = await Promise.resolve().then(() => (init_graph_mcp(), graph_mcp_exports));
+  startGraphMcpServer2();
+}
+main().catch((err2) => {
+  process.stderr.write(`[launch-chart] fatal: ${err2}
+`);
+  process.exit(1);
+});