@launchsecure/launch-kit 0.0.9 → 0.0.11

package/dist/server/cli.js

@@ -6363,41 +6363,160 @@ var import_node_path8 = require("node:path");
 var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
 
-// src/server/graph/core/ast-helpers.ts
+// src/server/graph/core/ts-extractor.ts
 var import_node_fs2 = require("node:fs");
 var import_node_path2 = require("node:path");
-var tsModule;
-function getTs() {
-  if (!tsModule) {
-    tsModule = require("typescript");
+var tsxLanguage;
+var parserInstance;
+var initPromise;
+var initialized = false;
+var queriesDir = (() => {
+  const srcPath = (0, import_node_path2.join)((0, import_node_path2.dirname)(__filename), "..", "queries");
+  if (require("fs").existsSync(srcPath)) return srcPath;
+  return (0, import_node_path2.join)((0, import_node_path2.dirname)(__filename), "graph", "queries");
+})();
+var queryCache = /* @__PURE__ */ new Map();
+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.");
+  }
+}
+function getQuery(name) {
+  ensureInit();
+  const cached = queryCache.get(name);
+  if (cached) return cached;
+  const scmPath = (0, import_node_path2.join)(queriesDir, `${name}.scm`);
+  const scm = (0, import_node_fs2.readFileSync)(scmPath, "utf-8");
+  const query = tsxLanguage.query(scm);
+  queryCache.set(name, query);
+  return query;
+}
+function parseSource(absPath) {
+  ensureInit();
+  const content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  return parserInstance.parse(content);
+}
+var PRISMA_MUTATION_METHODS_BUILTIN = [
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert",
+  "delete",
+  "deleteMany"
+];
+var DB_IDENTIFIERS_FALLBACK = ["db", "prisma"];
+var extraDbIdentifiers = [];
+var extraMutationMethods = [];
+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 tsModule;
+  return map;
 }
-var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
-function parseFile(absPath) {
-  const ts = getTs();
-  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,
-    content,
-    ts.ScriptTarget.Latest,
-    /* setParentNodes */
-    true,
-    scriptKind
-  );
+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);
@@ -6407,300 +6526,339 @@ 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;
-  }
-  function extractTargetFromExpression(expr) {
-    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
-      return { target: expr.text, isTemplate: false };
-    }
-    if (ts.isTemplateExpression(expr)) {
-      return { target: expr.getText(sourceFile), isTemplate: true };
+  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";
     }
-    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 };
+  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(arg)) {
-      if (!templateStartsWithSlash(arg)) return null;
-      return { url: arg.getText(sourceFile), isTemplate: true };
+    if (caps["reexport.wildcard.source"]) {
+      reExports.push({ name: "*", from: caps["reexport.wildcard.source"], isWildcard: 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;
+  }
+  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);
       }
-      if ((ts.isStringLiteral(leftmost) || ts.isNoSubstitutionTemplateLiteral(leftmost)) && leftmost.text.startsWith("/")) {
-        return { url: arg.getText(sourceFile), isTemplate: false, isConcat: true };
+    } else if (c.name === "jsx.member_tag") {
+      const rootName = c.node.text.split(".")[0];
+      if (rootName && /^[A-Z]/.test(rootName)) {
+        jsxElements.add(rootName);
       }
     }
-    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 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.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 });
-          }
-        }
-      } else if (!node.exportClause && fromSpec) {
-        reExports.push({ name: "*", from: fromSpec, isWildcard: 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 (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()
-        });
-      }
+    const linkLiteral = caps["nav.link.literal"] || caps["nav.link.literal.self"];
+    if (linkLiteral) {
+      navigations.push({ kind: "link-href", target: linkLiteral, isTemplate: false });
     }
-    if (ts.isExportAssignment(node) && !node.isExportEquals) {
-      if (ts.isIdentifier(node.expression)) {
-        addExport(node.expression.text, "default");
-      } else {
-        if (!defaultName) defaultName = "default";
-      }
+    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 (ts.isFunctionDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      const isDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
-      if (node.name) addExport(node.name.text, isDefault ? "default" : "value");
+    if (caps["nav.window.assign.target"]) {
+      navigations.push({ kind: "window-location", target: caps["nav.window.assign.target"], isTemplate: false });
     }
-    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");
+  }
+  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"
+      });
+    }
+  }
+  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);
+          }
         }
       }
     }
-    if (ts.isClassDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      const isDefault = hasModifier(node, ts.SyntaxKind.DefaultKeyword);
-      if (node.name) addExport(node.name.text, isDefault ? "default" : "value");
-    }
-    if (ts.isTypeAliasDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      addExport(node.name.text, "type");
+  }
+  if (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.isInterfaceDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      addExport(node.name.text, "type");
+  }
+  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 });
+    }
+    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");
+    }
+  }
+  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;
+    }
+  }
+  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"];
+    }
+    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
-  };
-}
-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_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 = [];
-  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_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();
-  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 };
 }
 
 // src/server/graph/parsers/ui/react-nextjs.ts
@@ -7026,7 +7184,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_path3.basename)(f).startsWith("index."));
@@ -7040,7 +7198,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);
@@ -7099,7 +7268,7 @@ function generate(rootDir) {
     if (externalScanned.has(normalized)) continue;
     let parsed;
     try {
-      parsed = parseFile(absPath);
+      parsed = parseFileTS(absPath);
     } catch {
       continue;
     }
@@ -7223,7 +7392,7 @@ var reactNextjsParser = {
 // src/server/graph/parsers/api/nextjs-routes.ts
 var import_node_fs4 = require("node:fs");
 var import_node_path4 = require("node:path");
-var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
 function walk2(dir) {
   const results = [];
   if (!(0, import_node_fs4.existsSync)(dir)) return results;
@@ -7262,12 +7431,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_path4.relative)(rootDir, absPath).replace(/\\/g, "/");
@@ -7286,6 +7455,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",
@@ -7297,7 +7467,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) {
@@ -7337,7 +7512,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;
       }, {}),
@@ -8192,9 +8367,10 @@ function matchParts(pat, pi, id, ii) {
   while (pi < pat.length && pat[pi] === "**") pi++;
   return pi === pat.length && ii === id.length;
 }
-var CONVENTION_DIRS = ["features", "modules", "domains", "areas"];
-function detectConventionDirs(rootDir) {
+var CONVENTION_DIRS_BUILTIN = ["features", "modules", "domains", "areas"];
+function detectConventionDirs(rootDir, extraConventionDirs = []) {
   const result = /* @__PURE__ */ new Map();
+  const conventionDirs = [...CONVENTION_DIRS_BUILTIN, ...extraConventionDirs];
   const searchDirs = [
     rootDir,
     (0, import_node_path10.join)(rootDir, "src"),
@@ -8202,7 +8378,7 @@ function detectConventionDirs(rootDir) {
     (0, import_node_path10.join)(rootDir, "lib")
   ];
   for (const base of searchDirs) {
-    for (const convention of CONVENTION_DIRS) {
+    for (const convention of conventionDirs) {
       const dir = (0, import_node_path10.join)(base, convention);
       if (!(0, import_node_fs9.existsSync)(dir)) continue;
       try {
@@ -8228,7 +8404,76 @@ function extractRouteGroups(id) {
   }
   return groups;
 }
-var SKIP_SEGMENTS = /* @__PURE__ */ new Set([
+var 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"
+]);
+var SKIP_SEGMENTS_BUILTIN = /* @__PURE__ */ new Set([
   "src",
   "app",
   "client",
@@ -8286,9 +8531,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];
@@ -8299,7 +8548,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) {
@@ -8316,12 +8565,10 @@ var moduleTagger = {
   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);
@@ -8330,8 +8577,21 @@ var moduleTagger = {
       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;
@@ -8357,7 +8617,7 @@ var moduleTagger = {
         }
       }
       if (matched) continue;
-      const module2 = extractModuleFromPath(id, extraTrivial);
+      const module2 = extractModuleFromPath(id, extraTrivial, extraSkipSegments);
       result.set(id, module2);
     }
     return result;
@@ -8585,7 +8845,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_fs11.mkdirSync)(dir, { recursive: true });
   const results = layer ? [generateLayer(rootDir, layer)].filter((r) => r !== null) : generateAll(rootDir);
@@ -8610,11 +8876,11 @@ function parseLayerFlag(args) {
   }
   return value;
 }
-function handleGraphCommand(subcommand, args) {
+async function handleGraphCommand(subcommand, args) {
   const rootDir = process.cwd();
   if (subcommand === "graph:generate") {
     const layer = parseLayerFlag(args);
-    const results = generateGraph(rootDir, layer);
+    const results = await generateGraph(rootDir, layer);
     if (results.length === 0) {
       console.error(
         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."
@@ -8768,7 +9034,7 @@ var TOOLS = [
   },
   {
     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: {
@@ -8813,6 +9079,14 @@ var TOOLS = [
           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.",
@@ -8835,7 +9109,7 @@ var TOOLS = [
   },
   {
     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.
 
@@ -8881,6 +9155,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 }. 
@@ -9009,6 +9317,14 @@ var COMPACT_NODE_KNOWN_KEYS = /* @__PURE__ */ new Set([
   "columns",
   "tags"
 ]);
+var DEEP_FIELDS = /* @__PURE__ */ new Set([
+  "elements",
+  "stateVars",
+  "conditions",
+  "variables",
+  "responses",
+  "params"
+]);
 var EST_CHARS_PER_NODE_FULL = {
   ui: 300,
   api: 300,
@@ -9036,7 +9352,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;
 }
@@ -9136,13 +9452,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."
@@ -9175,6 +9491,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` };
@@ -9246,18 +9564,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;
 }
@@ -9325,6 +9654,48 @@ function nodeToFilePath(rootDir, layer, nodeId) {
   if (layer === "db") return (0, import_node_path15.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;
@@ -9587,7 +9958,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") {
@@ -9610,7 +9981,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") {
@@ -9621,6 +9992,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;