@launchsecure/launch-kit 0.0.8 → 0.0.10

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 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\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.",
@@ -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 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?"
+
+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;