@launchsecure/launch-kit 0.0.9 → 0.0.11

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

@@ -155,37 +155,134 @@ var init_config = __esm({
   }
 });
 
-// src/server/graph/core/ast-helpers.ts
-function getTs() {
-  if (!tsModule) {
-    tsModule = require("typescript");
+// src/server/graph/core/ts-extractor.ts
+async function initTreeSitter() {
+  if (initialized) return;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    const TreeSitter = require("web-tree-sitter");
+    await TreeSitter.init();
+    const wasmPath = require.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
+    tsxLanguage = await TreeSitter.Language.load(wasmPath);
+    parserInstance = new TreeSitter();
+    parserInstance.setLanguage(tsxLanguage);
+    initialized = true;
+  })();
+  return initPromise;
+}
+function ensureInit() {
+  if (!initialized || !tsxLanguage || !parserInstance) {
+    throw new Error("Tree-sitter not initialized. Call initTreeSitter() first.");
   }
-  return tsModule;
 }
-function parseFile(absPath) {
-  const ts = getTs();
+function getQuery(name) {
+  ensureInit();
+  const cached = queryCache.get(name);
+  if (cached) return cached;
+  const scmPath = (0, import_node_path3.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs3.readFileSync)(scmPath, "utf-8");
+  const query = tsxLanguage.query(scm);
+  queryCache.set(name, query);
+  return query;
+}
+function parseSource(absPath) {
+  ensureInit();
   const content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path3.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
-  );
+  return parserInstance.parse(content);
+}
+function setExtractorConfig(config) {
+  extraDbIdentifiers = config.dbIdentifiers ?? [];
+  extraMutationMethods = config.mutationMethods ?? [];
+}
+function getMutationMethods() {
+  return /* @__PURE__ */ new Set([...PRISMA_MUTATION_METHODS_BUILTIN, ...extraMutationMethods]);
+}
+function getFallbackDbIdentifiers() {
+  return /* @__PURE__ */ new Set([...DB_IDENTIFIERS_FALLBACK, ...extraDbIdentifiers]);
+}
+function looksLikeUrl(s) {
+  return s.startsWith("/") || /^(https?:)?\/\//i.test(s);
+}
+function templateStartsWithSlash(text) {
+  const content = text.slice(1);
+  return content.startsWith("/");
+}
+function captureMap(match) {
+  const map = {};
+  for (const c of match.captures) {
+    map[c.name] = c.node.text;
+  }
+  return map;
+}
+function childrenOfType(node, type) {
+  return node.children.filter((n) => n.type === type);
+}
+function childOfType(node, type) {
+  return node.children.find((n) => n.type === type);
+}
+function parseFileTS(absPath) {
+  const tree = parseSource(absPath);
+  const root = tree.rootNode;
+  const imports = [];
+  const importStatements = childrenOfType(root, "import_statement");
+  for (const stmt of importStatements) {
+    const sourceNode = childOfType(stmt, "string");
+    const frag = sourceNode ? childOfType(sourceNode, "string_fragment") : void 0;
+    if (!frag) continue;
+    const specifier = frag.text;
+    const hasTypeKeyword = stmt.children.some(
+      (n) => n.type === "type" && n.text === "type"
+    );
+    const clause = childOfType(stmt, "import_clause");
+    if (!clause) {
+      imports.push({ names: [], specifier, isTypeOnly: false, typeNames: /* @__PURE__ */ new Set() });
+      continue;
+    }
+    const names = [];
+    const typeNames = /* @__PURE__ */ new Set();
+    const defaultId = childOfType(clause, "identifier");
+    if (defaultId) names.push(defaultId.text);
+    const nsImport = childOfType(clause, "namespace_import");
+    if (nsImport) {
+      const nsId = childOfType(nsImport, "identifier");
+      if (nsId) names.push(nsId.text);
+    }
+    const namedImports = childOfType(clause, "named_imports");
+    if (namedImports) {
+      for (const spec of childrenOfType(namedImports, "import_specifier")) {
+        const identifiers = childrenOfType(spec, "identifier");
+        const importedName = identifiers.length > 1 ? identifiers[identifiers.length - 1].text : identifiers[0]?.text;
+        if (importedName) {
+          names.push(importedName);
+          const specIsType = spec.children.some(
+            (n) => n.type === "type" && n.text === "type"
+          );
+          if (specIsType) typeNames.add(importedName);
+        }
+      }
+    }
+    if (names.length > 0 || hasTypeKeyword) {
+      imports.push({ names, specifier, isTypeOnly: hasTypeKeyword, typeNames });
+    }
+  }
+  const importQuery = getQuery("imports");
+  const importMatches = importQuery.matches(root);
+  for (const m of importMatches) {
+    const caps = captureMap(m);
+    if (caps["import.dynamic"]) {
+      imports.push({
+        names: [],
+        specifier: caps["import.dynamic"],
+        isTypeOnly: false,
+        typeNames: /* @__PURE__ */ new Set()
+      });
+    }
+  }
   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 = [];
-  const fetchCalls = [];
-  const includeConcat = process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1";
   function addExport(name2, kind) {
     if (!exportsSet.has(name2)) {
       exportsSet.add(name2);
@@ -195,298 +292,354 @@ function parseFile(absPath) {
     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;
+  const exportQuery = getQuery("exports");
+  const exportMatches = exportQuery.matches(root);
+  for (const m of exportMatches) {
+    const caps = captureMap(m);
+    if (caps["export.default.func"]) addExport(caps["export.default.func"], "default");
+    else if (caps["export.default.class"]) addExport(caps["export.default.class"], "default");
+    else if (caps["export.default.value"]) addExport(caps["export.default.value"], "default");
+    else if (caps["export.named.func"]) addExport(caps["export.named.func"], "value");
+    else if (caps["export.named.class"]) addExport(caps["export.named.class"], "value");
+    else if (caps["export.named.const"]) addExport(caps["export.named.const"], "value");
+    else if (caps["export.named.enum"]) addExport(caps["export.named.enum"], "value");
+    else if (caps["export.named.type"]) addExport(caps["export.named.type"], "type");
+    else if (caps["export.named.interface"]) addExport(caps["export.named.interface"], "type");
+    else if (caps["export.bare.name"]) addExport(caps["export.bare.name"], "value");
+    if (caps["reexport.name"]) addExport(caps["reexport.name"], "value");
+  }
+  for (const stmt of childrenOfType(root, "export_statement")) {
+    const hasDefault = stmt.children.some((n) => n.text === "default");
+    if (hasDefault && !defaultName) {
+      defaultName = "default";
+    }
   }
-  function extractTargetFromExpression(expr) {
-    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
-      return { target: expr.text, isTemplate: false };
+  const reExports = [];
+  for (const m of exportMatches) {
+    const caps = captureMap(m);
+    if (caps["reexport.name"] && caps["reexport.source"]) {
+      reExports.push({ name: caps["reexport.name"], from: caps["reexport.source"] });
     }
-    if (ts.isTemplateExpression(expr)) {
-      return { target: expr.getText(sourceFile), isTemplate: true };
+    if (caps["reexport.wildcard.source"]) {
+      reExports.push({ name: "*", from: caps["reexport.wildcard.source"], isWildcard: true });
     }
-    return null;
-  }
-  function looksLikeUrl(s) {
-    return s.startsWith("/") || /^(https?:)?\/\//i.test(s);
   }
-  function templateStartsWithSlash(expr) {
-    const head = expr.head.text;
-    return head.startsWith("/");
+  const jsxElements = /* @__PURE__ */ new Set();
+  const jsxQuery = getQuery("jsx-elements");
+  const jsxCaptures = jsxQuery.captures(root);
+  for (const c of jsxCaptures) {
+    if (c.name === "jsx.tag") {
+      if (/^[A-Z]/.test(c.node.text)) {
+        jsxElements.add(c.node.text);
+      }
+    } else if (c.name === "jsx.member_tag") {
+      const rootName = c.node.text.split(".")[0];
+      if (rootName && /^[A-Z]/.test(rootName)) {
+        jsxElements.add(rootName);
+      }
+    }
   }
-  function extractUrlFromFetchArg(arg) {
-    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
-      if (!looksLikeUrl(arg.text)) return null;
-      return { url: arg.text, isTemplate: false };
+  const navigations = [];
+  const navQuery = getQuery("navigations");
+  const navMatches = navQuery.matches(root);
+  for (const m of navMatches) {
+    const caps = captureMap(m);
+    if (caps["nav.target.literal"] && caps["nav.method"]) {
+      navigations.push({
+        kind: caps["nav.method"] === "push" ? "router-push" : "router-replace",
+        target: caps["nav.target.literal"],
+        isTemplate: false
+      });
     }
-    if (ts.isTemplateExpression(arg)) {
-      if (!templateStartsWithSlash(arg)) return null;
-      return { url: arg.getText(sourceFile), isTemplate: true };
+    if (caps["nav.target.template"] && caps["nav.method.template"]) {
+      navigations.push({
+        kind: caps["nav.method.template"] === "push" ? "router-push" : "router-replace",
+        target: caps["nav.target.template"],
+        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 };
-      }
+    const linkLiteral = caps["nav.link.literal"] || caps["nav.link.literal.self"];
+    if (linkLiteral) {
+      navigations.push({ kind: "link-href", target: linkLiteral, isTemplate: false });
+    }
+    const linkTemplate = caps["nav.link.template"] || caps["nav.link.template.self"];
+    if (linkTemplate) {
+      navigations.push({ kind: "link-href", target: linkTemplate, isTemplate: true });
+    }
+    if (caps["nav.window.literal"]) {
+      navigations.push({ kind: "window-location", target: caps["nav.window.literal"], isTemplate: false });
+    }
+    if (caps["nav.window.assign.target"]) {
+      navigations.push({ kind: "window-location", target: caps["nav.window.assign.target"], isTemplate: false });
     }
-    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 });
-        } else if (!clause) {
-          imports.push({ names: [], specifier, isTypeOnly: false, typeNames: /* @__PURE__ */ new Set() });
-        }
-      }
+  const fetchCalls = [];
+  const fetchQuery = getQuery("fetch-calls");
+  const fetchMatches = fetchQuery.matches(root);
+  for (const m of fetchMatches) {
+    const caps = captureMap(m);
+    if (caps["fetch.url.literal"] && looksLikeUrl(caps["fetch.url.literal"])) {
+      fetchCalls.push({ url: caps["fetch.url.literal"], isTemplate: false, kind: "fetch" });
+    }
+    if (caps["fetch.url.template"] && templateStartsWithSlash(caps["fetch.url.template"])) {
+      fetchCalls.push({ url: caps["fetch.url.template"], isTemplate: true, kind: "fetch" });
+    }
+    const clientUrl = caps["fetch.client.url.literal"] || caps["fetch.await.url.literal"];
+    const clientMethod = caps["fetch.method"] || caps["fetch.await.method"];
+    if (clientUrl && clientMethod && looksLikeUrl(clientUrl)) {
+      fetchCalls.push({
+        method: clientMethod.toUpperCase(),
+        url: clientUrl,
+        isTemplate: false,
+        kind: "client-method"
+      });
+    }
+    const clientUrlTpl = caps["fetch.client.url.template"] || caps["fetch.await.url.template"];
+    const clientMethodTpl = caps["fetch.method.template"] || caps["fetch.await.method.template"];
+    if (clientUrlTpl && clientMethodTpl && templateStartsWithSlash(clientUrlTpl)) {
+      fetchCalls.push({
+        method: clientMethodTpl.toUpperCase(),
+        url: clientUrlTpl,
+        isTemplate: true,
+        kind: "client-method"
+      });
     }
-    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 });
+  }
+  const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
+  return { name, exports: exportsOrdered, imports, reExports, jsxElements, navigations, fetchCalls };
+}
+function extractDbCallsTS(absPath) {
+  const tree = parseSource(absPath);
+  const root = tree.rootNode;
+  const dbQuery = getQuery("db-calls");
+  const matches = dbQuery.matches(root);
+  const dbIdentifiers = /* @__PURE__ */ new Set();
+  for (const stmt of childrenOfType(root, "import_statement")) {
+    const sourceNode = childOfType(stmt, "string");
+    const frag = sourceNode ? childOfType(sourceNode, "string_fragment") : void 0;
+    if (!frag) continue;
+    const spec = frag.text;
+    if (spec.includes("prisma") || spec.includes("/db") || spec === "@prisma/client") {
+      const clause = childOfType(stmt, "import_clause");
+      if (clause) {
+        const defaultId = childOfType(clause, "identifier");
+        if (defaultId) dbIdentifiers.add(defaultId.text);
+        const named = childOfType(clause, "named_imports");
+        if (named) {
+          for (const specNode of childrenOfType(named, "import_specifier")) {
+            const ids = childrenOfType(specNode, "identifier");
+            const importedName = ids[ids.length - 1];
+            if (importedName) dbIdentifiers.add(importedName.text);
           }
         }
-      } 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 (dbIdentifiers.size === 0) {
+    for (const id of getFallbackDbIdentifiers()) dbIdentifiers.add(id);
+  } else {
+    for (const id of extraDbIdentifiers) dbIdentifiers.add(id);
+  }
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    const caps = captureMap(m);
+    const identifier = caps["db.identifier"];
+    const model = caps["db.model"];
+    const method = caps["db.method"];
+    if (!identifier || !model || !method) continue;
+    if (!dbIdentifiers.has(identifier)) continue;
+    const key = `${model}.${method}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    calls.push({ model, method, isMutation: getMutationMethods().has(method) });
+  }
+  return calls;
+}
+function extractAuthWrappersTS(absPath) {
+  const tree = parseSource(absPath);
+  const root = tree.rootNode;
+  const wrapperQuery = getQuery("wrappers");
+  const matches = wrapperQuery.matches(root);
+  const wrappers = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    const caps = captureMap(m);
+    if (caps["wrapper.fn_name"]) {
+      wrappers.add(caps["wrapper.fn_name"]);
     }
-    if (ts.isExportAssignment(node) && !node.isExportEquals) {
-      if (ts.isIdentifier(node.expression)) {
-        addExport(node.expression.text, "default");
-      } else {
-        if (!defaultName) defaultName = "default";
-      }
+  }
+  return wrappers;
+}
+function trunc(s, max = 120) {
+  return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function extractDeep(absPath) {
+  const tree = parseSource(absPath);
+  const root = tree.rootNode;
+  const elements = [];
+  const elQuery = getQuery("deep/jsx-semantic");
+  const elMatches = elQuery.matches(root);
+  const elementMap = /* @__PURE__ */ new Map();
+  for (const m of elMatches) {
+    const tag = m.captures.find((c) => c.name === "el.tag")?.node;
+    if (!tag || !/^[A-Z]/.test(tag.text)) continue;
+    const elNode = m.captures.find((c) => c.name === "el.self" || c.name === "el.open")?.node;
+    const key = elNode ? `${elNode.startPosition.row}:${elNode.startPosition.column}` : `${tag.startPosition.row}:${tag.startPosition.column}`;
+    if (!elementMap.has(key)) {
+      elementMap.set(key, { tag: tag.text, props: {}, nodeKey: key });
     }
-    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");
+    const entry = elementMap.get(key);
+    const propName = m.captures.find((c) => c.name === "el.prop.name")?.node.text;
+    const propVal = m.captures.find((c) => c.name === "el.prop.value.str")?.node.text;
+    const propExpr = m.captures.find((c) => c.name === "el.prop.value.expr")?.node.text;
+    if (propName) {
+      entry.props[propName] = propVal ?? (propExpr ? trunc(propExpr, 60) : "true");
     }
-    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");
-        }
+  }
+  for (const m of elMatches) {
+    const textTag = m.captures.find((c) => c.name === "el.text.tag")?.node;
+    const textContent = m.captures.find((c) => c.name === "el.text.content")?.node;
+    if (textTag && textContent && /^[A-Z]/.test(textTag.text)) {
+      const key = `${textTag.startPosition.row}:${textTag.startPosition.column}`;
+      if (!elementMap.has(key)) {
+        elementMap.set(key, { tag: textTag.text, props: {}, nodeKey: key });
       }
+      const entry = elementMap.get(key);
+      const text = textContent.text.trim();
+      if (text) entry.props["_text"] = text;
     }
-    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");
+  }
+  for (const entry of elementMap.values()) {
+    const el = { tag: entry.tag, props: entry.props };
+    const hasExpr = Object.values(entry.props).some((v) => v.includes("{") || v.includes("("));
+    if (hasExpr) el.dynamic = true;
+    if (entry.props["_text"]) {
+      el.text = entry.props["_text"];
+      delete el.props["_text"];
     }
-    if (ts.isInterfaceDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      addExport(node.name.text, "type");
+    elements.push(el);
+  }
+  const stateVars = [];
+  const hookQuery = getQuery("deep/state-hooks");
+  const hookMatches = hookQuery.matches(root);
+  for (const m of hookMatches) {
+    const caps = captureMap(m);
+    if (caps["hook.var"] && caps["hook.setter"] && caps["hook.fn"]) {
+      stateVars.push({
+        name: caps["hook.var"],
+        setter: caps["hook.setter"],
+        hook: caps["hook.fn"],
+        init: trunc(caps["hook.init"] ?? "", 80)
+      });
     }
-    if (ts.isEnumDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      addExport(node.name.text, "value");
+    if (caps["reducer.var"] && caps["reducer.dispatch"]) {
+      stateVars.push({
+        name: caps["reducer.var"],
+        setter: caps["reducer.dispatch"],
+        hook: "useReducer",
+        init: trunc(caps["reducer.init"] ?? "", 80)
+      });
     }
-    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);
-        }
-      }
+  }
+  const conditions = [];
+  const condQuery = getQuery("deep/conditions");
+  const condMatches = condQuery.matches(root);
+  for (const m of condMatches) {
+    const caps = captureMap(m);
+    if (caps["cond.test"]) {
+      conditions.push({
+        kind: "if",
+        test: trunc(caps["cond.test"], 100),
+        consequence: caps["cond.consequence"] ? trunc(caps["cond.consequence"], 80) : void 0
+      });
     }
-    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 (caps["ternary.test"]) {
+      conditions.push({
+        kind: "ternary",
+        test: trunc(caps["ternary.test"], 100)
+      });
     }
-    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"
-            });
-          }
-        }
-      }
+  }
+  const variables = [];
+  const varQuery = getQuery("deep/variables");
+  const varMatches = varQuery.matches(root);
+  for (const m of varMatches) {
+    const caps = captureMap(m);
+    const declNode = m.captures.find((c) => c.name === "var.decl" || c.name === "var.destructured" || c.name === "var.array")?.node;
+    const kind = declNode?.children.find((n) => n.type === "const" || n.type === "let" || n.type === "var")?.type ?? "const";
+    if (caps["var.name"] && caps["var.init"]) {
+      variables.push({
+        name: caps["var.name"],
+        kind,
+        init: trunc(caps["var.init"], 100)
+      });
     }
-    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 (caps["var.destructured.obj"]) {
+      variables.push({
+        name: trunc(caps["var.destructured.obj"], 60),
+        kind,
+        init: trunc(caps["var.destructured.init"], 100)
+      });
     }
-    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 (caps["var.array.pattern"]) {
+      variables.push({
+        name: trunc(caps["var.array.pattern"], 60),
+        kind,
+        init: trunc(caps["var.array.init"], 100)
+      });
     }
-    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 });
-          }
-        }
-      }
+  }
+  const responses = [];
+  const respQuery = getQuery("deep/responses");
+  const respMatches = respQuery.matches(root);
+  const explicitBodies = /* @__PURE__ */ new Set();
+  for (const m of respMatches) {
+    const caps = captureMap(m);
+    if (caps["resp.status"] && caps["resp.body"]) {
+      explicitBodies.add(trunc(caps["resp.body"], 80));
+      responses.push({
+        status: caps["resp.status"],
+        body: trunc(caps["resp.body"], 80)
+      });
     }
-    ts.forEachChild(node, visit);
   }
-  visit(sourceFile);
-  const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
-  return {
-    name,
-    exports: exportsOrdered,
-    imports,
-    reExports,
-    jsxElements,
-    navigations,
-    fetchCalls
-  };
-}
-function extractDbCalls(absPath) {
-  const ts = getTs();
-  const content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path3.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)
-          });
-        }
+  for (const m of respMatches) {
+    const caps = captureMap(m);
+    if (caps["resp.body.default"] && !caps["resp.status"]) {
+      const bodyText = trunc(caps["resp.body.default"], 80);
+      if (!explicitBodies.has(bodyText)) {
+        responses.push({ status: "200", body: bodyText });
       }
     }
-    ts.forEachChild(node, visit);
   }
-  visit(sourceFile);
-  return calls;
-}
-function extractAuthWrappers(absPath) {
-  const ts = getTs();
-  const content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
-  const ext = (0, import_node_path3.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);
-      }
+  const params = [];
+  const paramQuery = getQuery("deep/request-params");
+  const paramMatches = paramQuery.matches(root);
+  for (const m of paramMatches) {
+    const caps = captureMap(m);
+    if (caps["param.name"]) {
+      params.push({ name: caps["param.name"], source: "body-field" });
+    }
+    if (caps["param.body"]) {
+      params.push({ name: caps["param.body"], source: "body" });
     }
-    ts.forEachChild(node, visit);
   }
-  visit(sourceFile);
-  return wrappers;
+  return { elements, stateVars, conditions, variables, responses, params };
 }
-var import_node_fs3, import_node_path3, tsModule, HTTP_METHODS, MUTATION_METHODS;
-var init_ast_helpers = __esm({
-  "src/server/graph/core/ast-helpers.ts"() {
+var import_node_fs3, import_node_path3, tsxLanguage, parserInstance, initPromise, initialized, queriesDir, queryCache, PRISMA_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods;
+var init_ts_extractor = __esm({
+  "src/server/graph/core/ts-extractor.ts"() {
     "use strict";
     import_node_fs3 = require("node:fs");
     import_node_path3 = require("node:path");
-    HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
-    MUTATION_METHODS = /* @__PURE__ */ new Set([
+    initialized = false;
+    queriesDir = (() => {
+      const srcPath = (0, import_node_path3.join)((0, import_node_path3.dirname)(__filename), "..", "queries");
+      if (require("fs").existsSync(srcPath)) return srcPath;
+      return (0, import_node_path3.join)((0, import_node_path3.dirname)(__filename), "graph", "queries");
+    })();
+    queryCache = /* @__PURE__ */ new Map();
+    PRISMA_MUTATION_METHODS_BUILTIN = [
       "create",
       "createMany",
       "createManyAndReturn",
@@ -496,7 +649,10 @@ var init_ast_helpers = __esm({
       "upsert",
       "delete",
       "deleteMany"
-    ]);
+    ];
+    DB_IDENTIFIERS_FALLBACK = ["db", "prisma"];
+    extraDbIdentifiers = [];
+    extraMutationMethods = [];
   }
 });
 
@@ -822,7 +978,7 @@ function generate(rootDir) {
   const allDiscovered = [...appFiles, ...clientFiles, ...serverFiles, ...libFiles, ...configFiles];
   const parsedByPath = /* @__PURE__ */ new Map();
   for (const absPath of allDiscovered) {
-    parsedByPath.set(absPath, parseFile(absPath));
+    parsedByPath.set(absPath, parseFileTS(absPath));
   }
   const barrelMaps = buildAllBarrelMaps(srcDir, parsedByPath);
   const fileSet = allDiscovered.filter((f) => !(0, import_node_path4.basename)(f).startsWith("index."));
@@ -836,7 +992,18 @@ function generate(rootDir) {
     const parsed = parsedByPath.get(absPath);
     const name = parsed.name || nameFromFilename(absPath);
     const route = extractRoute(id);
-    nodes.push({ id, type, name, route, exports: parsed.exports });
+    const deep = extractDeep(absPath);
+    nodes.push({
+      id,
+      type,
+      name,
+      route,
+      exports: parsed.exports,
+      elements: deep.elements,
+      stateVars: deep.stateVars,
+      conditions: deep.conditions,
+      variables: deep.variables
+    });
     nodeIdSet.add(id);
     nodeTypeMap.set(id, type);
     if (route) routeToNodeId.set(route, id);
@@ -895,7 +1062,7 @@ function generate(rootDir) {
     if (externalScanned.has(normalized)) continue;
     let parsed;
     try {
-      parsed = parseFile(absPath);
+      parsed = parseFileTS(absPath);
     } catch {
       continue;
     }
@@ -1015,7 +1182,7 @@ var init_react_nextjs = __esm({
     "use strict";
     import_node_fs4 = require("node:fs");
     import_node_path4 = require("node:path");
-    init_ast_helpers();
+    init_ts_extractor();
     RENDER_TYPES = /* @__PURE__ */ new Set(["component", "ui", "layout", "context"]);
     reactNextjsParser = {
       id: "react-nextjs",
@@ -1065,12 +1232,12 @@ function generate2(rootDir) {
   let endpointsWithAuth = 0;
   let endpointsWithDbAccess = 0;
   for (const absPath of routeFiles) {
-    const parsed = parseFile(absPath);
-    const dbCalls = extractDbCalls(absPath);
-    const authWrappers = extractAuthWrappers(absPath);
+    const parsed = parseFileTS(absPath);
+    const dbCalls = extractDbCallsTS(absPath);
+    const authWrappers = extractAuthWrappersTS(absPath);
     const methods = [];
     for (const exp of parsed.exports) {
-      if (HTTP_METHODS2.has(exp)) methods.push(exp);
+      if (HTTP_METHODS.has(exp)) methods.push(exp);
     }
     const routePath = filePathToRoute(apiDir, absPath);
     const relPath = (0, import_node_path5.relative)(rootDir, absPath).replace(/\\/g, "/");
@@ -1089,6 +1256,7 @@ function generate2(rootDir) {
       authUsage[w] = (authUsage[w] ?? 0) + 1;
     }
     if (authStrategy.length > 0) endpointsWithAuth++;
+    const deep = extractDeep(absPath);
     nodes.push({
       id: relPath,
       type: "endpoint",
@@ -1100,7 +1268,12 @@ function generate2(rootDir) {
       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}`))]
+      db_operations: [...new Set(dbCalls.map((c) => `${c.model}.${c.method}`))],
+      // Deep extraction fields
+      conditions: deep.conditions,
+      variables: deep.variables,
+      responses: deep.responses,
+      params: deep.params
     });
     const seenModels = /* @__PURE__ */ new Set();
     for (const call of dbCalls) {
@@ -1140,7 +1313,7 @@ function generate2(rootDir) {
     flagged_edges: [],
     patterns: {
       total_endpoints: nodes.length,
-      methods_breakdown: [...HTTP_METHODS2].reduce((acc, m) => {
+      methods_breakdown: [...HTTP_METHODS].reduce((acc, m) => {
         acc[m] = nodes.filter((n) => n.methods.includes(m)).length;
         return acc;
       }, {}),
@@ -1150,14 +1323,14 @@ function generate2(rootDir) {
     }
   };
 }
-var import_node_fs5, import_node_path5, HTTP_METHODS2, nextjsRoutesParser;
+var import_node_fs5, import_node_path5, HTTP_METHODS, nextjsRoutesParser;
 var init_nextjs_routes = __esm({
   "src/server/graph/parsers/api/nextjs-routes.ts"() {
     "use strict";
     import_node_fs5 = require("node:fs");
     import_node_path5 = require("node:path");
-    init_ast_helpers();
-    HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+    init_ts_extractor();
+    HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
     nextjsRoutesParser = {
       id: "nextjs-routes",
       layer: "api",
@@ -2058,8 +2231,9 @@ function matchParts(pat, pi, id, ii) {
   while (pi < pat.length && pat[pi] === "**") pi++;
   return pi === pat.length && ii === id.length;
 }
-function detectConventionDirs(rootDir) {
+function detectConventionDirs(rootDir, extraConventionDirs = []) {
   const result = /* @__PURE__ */ new Map();
+  const conventionDirs = [...CONVENTION_DIRS_BUILTIN, ...extraConventionDirs];
   const searchDirs = [
     rootDir,
     (0, import_node_path11.join)(rootDir, "src"),
@@ -2067,7 +2241,7 @@ function detectConventionDirs(rootDir) {
     (0, import_node_path11.join)(rootDir, "lib")
   ];
   for (const base of searchDirs) {
-    for (const convention of CONVENTION_DIRS) {
+    for (const convention of conventionDirs) {
       const dir = (0, import_node_path11.join)(base, convention);
       if (!(0, import_node_fs10.existsSync)(dir)) continue;
       try {
@@ -2120,9 +2294,13 @@ function isTrivialGroup(name, extraTrivial) {
 function normalizeGroupName(name) {
   return name.toLowerCase().replace(/-pages?$/, "").replace(/-layout$/, "").replace(/-wrapper$/, "");
 }
-function extractModuleFromPath(id, extraTrivial) {
+function extractModuleFromPath(id, extraTrivial, extraSkipSegments) {
   const segments = id.split("/");
   const routeGroups = extractRouteGroups(id);
+  const skipSegments = new Set(SKIP_SEGMENTS_BUILTIN);
+  if (extraSkipSegments) {
+    for (const s of extraSkipSegments) skipSegments.add(s);
+  }
   const moduleGroups = routeGroups.filter((g) => !isTrivialGroup(g, extraTrivial)).map(normalizeGroupName);
   if (moduleGroups.length > 0) {
     return moduleGroups[moduleGroups.length - 1];
@@ -2133,7 +2311,7 @@ function extractModuleFromPath(id, extraTrivial) {
     if (isRouteGroup(seg)) continue;
     if (isDynamicSegment(seg)) continue;
     if (isDomainDir(seg)) continue;
-    if (SKIP_SEGMENTS.has(seg)) continue;
+    if (skipSegments.has(seg)) continue;
     meaningful.push(seg);
   }
   if (meaningful.length > 0) {
@@ -2141,14 +2319,83 @@ function extractModuleFromPath(id, extraTrivial) {
   }
   return "root";
 }
-var import_node_fs10, import_node_path11, CONVENTION_DIRS, SKIP_SEGMENTS, TRIVIAL_GROUPS, cachedRootDir, cachedConventionDirs, moduleTagger;
+var import_node_fs10, import_node_path11, CONVENTION_DIRS_BUILTIN, GENERIC_ROLE_NAMES_BUILTIN, SKIP_SEGMENTS_BUILTIN, TRIVIAL_GROUPS, cachedRootDir, cachedConventionDirs, moduleTagger;
 var init_module_tagger = __esm({
   "src/server/graph/taggers/module-tagger.ts"() {
     "use strict";
     import_node_fs10 = require("node:fs");
     import_node_path11 = require("node:path");
-    CONVENTION_DIRS = ["features", "modules", "domains", "areas"];
-    SKIP_SEGMENTS = /* @__PURE__ */ new Set([
+    CONVENTION_DIRS_BUILTIN = ["features", "modules", "domains", "areas"];
+    GENERIC_ROLE_NAMES_BUILTIN = /* @__PURE__ */ new Set([
+      // JS/TS
+      "components",
+      "hooks",
+      "pages",
+      "views",
+      "screens",
+      "layouts",
+      "utils",
+      "helpers",
+      "lib",
+      "libs",
+      "services",
+      "api",
+      "apis",
+      "stores",
+      "state",
+      "store",
+      "context",
+      "contexts",
+      "providers",
+      "types",
+      "interfaces",
+      "models",
+      "schemas",
+      "constants",
+      "config",
+      "configs",
+      "assets",
+      "styles",
+      "public",
+      "middleware",
+      "middlewares",
+      "routes",
+      "router",
+      "tests",
+      "test",
+      "__tests__",
+      "spec",
+      "specs",
+      // Go
+      "cmd",
+      "pkg",
+      "internal",
+      // Python
+      "management",
+      "migrations",
+      "templatetags",
+      "templates",
+      // Java
+      "controller",
+      "controllers",
+      "service",
+      "repository",
+      "repositories",
+      "entity",
+      "entities",
+      "dto",
+      "dtos",
+      // General
+      "shared",
+      "common",
+      "core",
+      "base",
+      "app",
+      // Next.js specific
+      "client",
+      "server"
+    ]);
+    SKIP_SEGMENTS_BUILTIN = /* @__PURE__ */ new Set([
       "src",
       "app",
       "client",
@@ -2188,12 +2435,10 @@ var init_module_tagger = __esm({
       layers: null,
       // applies to all layers
       tag(nodes, layer, rootDir) {
-        if (cachedRootDir !== rootDir) {
-          cachedConventionDirs = detectConventionDirs(rootDir);
-          cachedRootDir = rootDir;
-        }
         let configRules = [];
         let extraTrivial;
+        let extraSkipSegments;
+        let extraConventionDirs = [];
         try {
           const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
           const config = loadConfig2(rootDir);
@@ -2202,8 +2447,21 @@ var init_module_tagger = __esm({
           if (trivialFromConfig?.length) {
             extraTrivial = new Set(trivialFromConfig);
           }
+          const skipFromConfig = config.taggers?.module?.skipSegments;
+          if (skipFromConfig?.length) {
+            extraSkipSegments = new Set(skipFromConfig);
+          }
+          extraConventionDirs = config.taggers?.module?.conventionDirs ?? [];
+          const roleNamesFromConfig = config.taggers?.module?.genericRoleNames;
+          if (roleNamesFromConfig?.length) {
+            for (const name of roleNamesFromConfig) GENERIC_ROLE_NAMES_BUILTIN.add(name);
+          }
         } catch {
         }
+        if (cachedRootDir !== rootDir) {
+          cachedConventionDirs = detectConventionDirs(rootDir, extraConventionDirs);
+          cachedRootDir = rootDir;
+        }
         const result = /* @__PURE__ */ new Map();
         for (const node of nodes) {
           const id = node.id;
@@ -2229,7 +2487,7 @@ var init_module_tagger = __esm({
             }
           }
           if (matched) continue;
-          const module2 = extractModuleFromPath(id, extraTrivial);
+          const module2 = extractModuleFromPath(id, extraTrivial, extraSkipSegments);
           result.set(id, module2);
         }
         return result;
@@ -2476,7 +2734,13 @@ function readAllGraphs(rootDir) {
   }
   return result;
 }
-function generateGraph(rootDir, layer) {
+async function generateGraph(rootDir, layer) {
+  await initTreeSitter();
+  const config = loadConfig(rootDir);
+  setExtractorConfig({
+    dbIdentifiers: config.parsers?.patterns?.dbIdentifiers,
+    mutationMethods: config.parsers?.patterns?.mutationMethods
+  });
   const dir = graphsDir(rootDir);
   (0, import_node_fs12.mkdirSync)(dir, { recursive: true });
   const results = layer ? [generateLayer(rootDir, layer)].filter((r) => r !== null) : generateAll(rootDir);
@@ -2498,6 +2762,7 @@ var init_graph = __esm({
     init_config();
     init_tagger_registry();
     init_tag_store();
+    init_ts_extractor();
     init_tag_store();
     GRAPHS_DIR2 = ".launchsecure/graphs";
     LAYERS = ["ui", "api", "db"];
@@ -2533,10 +2798,10 @@ function findProjectRoot(startDir) {
   }
   return startDir;
 }
-function buildMergedGraph(projectRoot) {
+async function buildMergedGraph(projectRoot) {
   let graphs = readAllGraphs(projectRoot);
   if (!graphs.ui && !graphs.api && !graphs.db) {
-    generateGraph(projectRoot);
+    await generateGraph(projectRoot);
     graphs = readAllGraphs(projectRoot);
   }
   const nodes = [];
@@ -2646,13 +2911,18 @@ async function startChartServer(opts = {}) {
       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 }
-        }));
+        (async () => {
+          if (regenerate) await generateGraph(projectRoot);
+          const merged = await buildMergedGraph(projectRoot);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            ...merged,
+            debug: { cwd, projectRoot }
+          }));
+        })().catch((e) => {
+          res.writeHead(500);
+          res.end(String(e));
+        });
         return;
       }
       if (req.method === "GET" && url2.pathname === "/api/raw-graphs") {
@@ -2662,8 +2932,8 @@ async function startChartServer(opts = {}) {
         return;
       }
       if (req.method === "POST" && url2.pathname === "/api/generate-graph") {
-        try {
-          generateGraph(projectRoot);
+        (async () => {
+          await generateGraph(projectRoot);
           const graphs = readAllGraphs(projectRoot);
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({
@@ -2672,10 +2942,10 @@ async function startChartServer(opts = {}) {
             api: graphs.api ?? null,
             db: graphs.db ?? null
           }));
-        } catch (err2) {
+        })().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/file-content") {
@@ -2941,7 +3211,7 @@ function toCompactNode(n) {
   if (n.columns != null) out.c = n.columns;
   if (tags != null) out.tg = tags;
   for (const k of Object.keys(n)) {
-    if (!COMPACT_NODE_KNOWN_KEYS.has(k) && n[k] != null) out[k] = n[k];
+    if (!COMPACT_NODE_KNOWN_KEYS.has(k) && !DEEP_FIELDS.has(k) && n[k] != null) out[k] = n[k];
   }
   return out;
 }
@@ -3041,13 +3311,13 @@ function okJson(data) {
 function err(text) {
   return { content: [{ type: "text", text }], isError: true };
 }
-function handleGenerateGraph(args) {
+async 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);
+  const results = await 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."
@@ -3080,6 +3350,8 @@ function runReadGraphQueryRaw(rootDir, args) {
   const layerIsDb = args.layer === "db";
   const minimal = args.minimal ?? layerIsDb;
   const includeEdges = args.include_edges;
+  const offset = args.offset ?? 0;
+  const limit = args.limit;
   const hasFilter = !!(search || type || module_ || nodeId || tagKey && tagValue);
   if (layer && !["ui", "api", "db"].includes(layer)) {
     return { error: `Invalid layer "${layer}". Must be one of: ui, api, db` };
@@ -3151,18 +3423,29 @@ function runReadGraphQueryRaw(rootDir, args) {
       hint: "No nodes matched. Check spelling, or call read_graph without filter to see the summary and available types/modules."
     };
   }
+  const totalMatched = matched.length;
+  const paginatedNodes = limit != null ? matched.slice(offset, offset + limit) : matched.slice(offset);
+  const hasMore = offset + paginatedNodes.length < totalMatched;
   const wantEdges = includeEdges ?? false;
+  const returnedIds = new Set(paginatedNodes.map((n) => n.id));
+  const returnedEdges = graph.edges.filter((e) => returnedIds.has(e.source) && returnedIds.has(e.target));
   const result = {
     layer,
     filter: { search, type, module: module_ },
-    matched: matched.length,
-    edge_count: matchedEdges.length,
-    nodes: minimal ? toMinimal(matched) : matched
+    total: totalMatched,
+    returned: paginatedNodes.length,
+    offset,
+    has_more: hasMore,
+    edge_count: returnedEdges.length,
+    nodes: minimal ? toMinimal(paginatedNodes) : paginatedNodes
   };
+  if (hasMore) {
+    result.next_offset = offset + paginatedNodes.length;
+  }
   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).`;
+    result.edges = returnedEdges;
+  } else if (returnedEdges.length > 0) {
+    result.edges_hint = `${returnedEdges.length} edges between matched nodes omitted. Pass include_edges:true to retrieve them (only do this when you actually need edge data).`;
   }
   return result;
 }
@@ -3230,6 +3513,48 @@ function nodeToFilePath(rootDir, layer, nodeId) {
   if (layer === "db") return (0, import_node_path16.join)(rootDir, "prisma", "schema.prisma");
   return null;
 }
+function handleInspectNode(args) {
+  const rootDir = process.cwd();
+  const layer = args.layer;
+  const nodeId = args.node_id;
+  const search = args.search;
+  const fields = args.fields;
+  if (!layer) return err("layer is required.");
+  if (!nodeId && !search) return err("Either node_id or search is required.");
+  const graph = readGraph(rootDir, layer);
+  if (!graph) return err(`No graph found for layer "${layer}". Run generate_graph first.`);
+  let matched;
+  if (nodeId) {
+    const node = graph.nodes.find((n) => n.id === nodeId);
+    if (!node) return err(`Node "${nodeId}" not found in ${layer} layer.`);
+    matched = [node];
+  } else {
+    const searchLower = search.toLowerCase();
+    matched = graph.nodes.filter(
+      (n) => n.id.toLowerCase().includes(searchLower) || n.name.toLowerCase().includes(searchLower) || n.route?.toLowerCase().includes(searchLower)
+    );
+  }
+  if (matched.length === 0) return err(`No nodes matching "${search}" in ${layer} layer.`);
+  if (matched.length > 5) {
+    return err(`${matched.length} nodes match "${search}". Narrow your search (max 5 for inspect_node).`);
+  }
+  const allDeepFields = ["elements", "stateVars", "conditions", "variables", "responses", "params"];
+  const requestedFields = fields ?? allDeepFields;
+  const results = matched.map((node) => {
+    const deep = { id: node.id, name: node.name, type: node.type };
+    for (const field of requestedFields) {
+      if (allDeepFields.includes(field) && node[field] != null) {
+        deep[field] = node[field];
+      }
+    }
+    return deep;
+  });
+  return okJson({
+    layer,
+    matched: results.length,
+    nodes: results
+  });
+}
 function handleGrepNodes(args) {
   const rootDir = process.cwd();
   const pattern = args.pattern;
@@ -3492,7 +3817,7 @@ function respond(id, result) {
 function respondError(id, code, message) {
   send({ jsonrpc: "2.0", id, error: { code, message } });
 }
-function handleMessage(msg) {
+async function handleMessage(msg) {
   const method = msg.method;
   const id = msg.id;
   if (method === "initialize") {
@@ -3515,7 +3840,7 @@ function handleMessage(msg) {
     const toolName = params.name;
     const args = params.arguments ?? {};
     if (toolName === "generate_graph") {
-      respond(id ?? null, handleGenerateGraph(args));
+      respond(id ?? null, await handleGenerateGraph(args));
       return;
     }
     if (toolName === "read_graph") {
@@ -3526,6 +3851,10 @@ function handleMessage(msg) {
       respond(id ?? null, handleGrepNodes(args));
       return;
     }
+    if (toolName === "inspect_node") {
+      respond(id ?? null, handleInspectNode(args));
+      return;
+    }
     if (toolName === "chart_server_status") {
       respond(id ?? null, handleChartServerStatus());
       return;
@@ -3585,7 +3914,7 @@ function startGraphMcpServer() {
   process.stderr.write(`[launchsecure-graph] MCP server started (cwd: ${process.cwd()})
 `);
 }
-var import_node_fs14, import_node_path16, import_node_child_process2, import_node_os2, 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 import_node_fs14, import_node_path16, import_node_child_process2, import_node_os2, SERVER_INFO, TOOLS, COMPACT_SCHEMA, COMPACT_NODE_KNOWN_KEYS, DEEP_FIELDS, 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";
@@ -3620,7 +3949,7 @@ var init_graph_mcp = __esm({
       },
       {
         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 tag (computed from directory structure, e.g. "auth", "admin", "settings")\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.',
+        description: 'Query the structural project graph \u2014 use INSTEAD of Glob and Grep for locating files, understanding structure, and navigating the codebase. Faster and more accurate than file-system search because it returns typed nodes with metadata and relationships. \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", "which endpoints touch the User table", "what auth strategy does this endpoint use". \n\nDO NOT USE FOR: understanding what\'s INSIDE a component (use inspect_node for elements, conditions, state, variables, responses), reading actual source code (use Read). \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 tag (computed from directory structure, e.g. "auth", "admin", "settings")\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\nPAGINATION (filter queries):\n- Use `offset` and `limit` to paginate through large result sets.\n- Response includes: `total` (matched), `returned` (in this page), `has_more`, `next_offset`.\n- If `has_more: true`, call again with `offset: next_offset` to get the next page.\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: {
@@ -3665,6 +3994,14 @@ var init_graph_mcp = __esm({
               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."
             },
+            offset: {
+              type: "number",
+              description: "Skip first N matched nodes (pagination). Default 0. Use next_offset from a previous response to get the next page."
+            },
+            limit: {
+              type: "number",
+              description: "Max nodes to return. Default: all matched nodes. Use with offset for pagination."
+            },
             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.",
@@ -3687,7 +4024,7 @@ var init_graph_mcp = __esm({
       },
       {
         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.
+        description: `Search for text patterns WITHIN files selected by the project graph. Use INSTEAD of Grep when searching within code \u2014 combines structural filtering (type/module/neighborhood) with regex content search. 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.
 
@@ -3733,6 +4070,40 @@ Returns: { pattern, filter, files_searched, total_matches, matches: [{file, line
           required: ["layer", "pattern"]
         }
       },
+      {
+        name: "inspect_node",
+        description: `Get deep AST data for specific graph nodes \u2014 what's INSIDE a component or endpoint. Returns elements (JSX), state hooks, conditions, variables, responses, and request params. Use INSTEAD of Grep/Read when you need to understand component internals without reading source.
+
+USE THIS FOR: "what elements does LoginPage have?", "what conditions does the login endpoint check?", "what state does SettingsPage manage?", "what responses can this endpoint return?", "what validation does this API do?", "what props does this component accept?"
+
+DO NOT USE FOR: structural queries (use read_graph), content search (use grep_nodes).
+
+Returns deep fields only \u2014 not structural metadata (use read_graph for that).`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            layer: {
+              type: "string",
+              enum: ["ui", "api", "db"],
+              description: "Graph layer (required)."
+            },
+            node_id: {
+              type: "string",
+              description: "Node ID to inspect. Use read_graph to find node IDs first."
+            },
+            search: {
+              type: "string",
+              description: "Substring match on node id/name/route. Returns deep data for all matching nodes (max 5)."
+            },
+            fields: {
+              type: "array",
+              items: { type: "string" },
+              description: "Specific deep fields to return. Options: elements, stateVars, conditions, variables, responses, params. Omit for all."
+            }
+          },
+          required: ["layer"]
+        }
+      },
       {
         name: "chart_server_status",
         description: `Check whether the launch-chart UI server is running. Returns: { running: boolean, url?: string, port?: number, pid?: number, startedAt?: string, cwd?: string }. 
@@ -3844,6 +4215,14 @@ Use this when the user asks "is the chart running", "show me the project graph U
       "columns",
       "tags"
     ]);
+    DEEP_FIELDS = /* @__PURE__ */ new Set([
+      "elements",
+      "stateVars",
+      "conditions",
+      "variables",
+      "responses",
+      "params"
+    ]);
     EST_CHARS_PER_NODE_FULL = {
       ui: 300,
       api: 300,