@launchsecure/launch-kit 0.0.9 → 0.0.10

package/dist/server/chart-serve.js

@@ -81,41 +81,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);
@@ -125,300 +244,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 };
-    }
-    if (ts.isTemplateExpression(arg)) {
-      if (!templateStartsWithSlash(arg)) return null;
-      return { url: arg.getText(sourceFile), isTemplate: true };
+  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 (includeConcat && ts.isBinaryExpression(arg) && arg.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-      let leftmost = arg;
-      while (ts.isBinaryExpression(leftmost) && leftmost.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-        leftmost = leftmost.left;
-      }
-      if ((ts.isStringLiteral(leftmost) || ts.isNoSubstitutionTemplateLiteral(leftmost)) && leftmost.text.startsWith("/")) {
-        return { url: arg.getText(sourceFile), isTemplate: false, isConcat: true };
-      }
+    if (caps["reexport.wildcard.source"]) {
+      reExports.push({ name: "*", from: caps["reexport.wildcard.source"], isWildcard: true });
     }
-    return null;
   }
-  function visit(node) {
-    if (ts.isImportDeclaration(node)) {
-      const moduleSpec = node.moduleSpecifier;
-      if (ts.isStringLiteral(moduleSpec)) {
-        const specifier = moduleSpec.text;
-        const clause = node.importClause;
-        const isTypeOnly = !!clause?.isTypeOnly;
-        const names = [];
-        const typeNames = /* @__PURE__ */ new Set();
-        if (clause) {
-          if (clause.name) names.push(clause.name.text);
-          const nb = clause.namedBindings;
-          if (nb && ts.isNamedImports(nb)) {
-            for (const el of nb.elements) {
-              names.push(el.name.text);
-              if (el.isTypeOnly) typeNames.add(el.name.text);
-            }
-          } else if (nb && ts.isNamespaceImport(nb)) {
-            names.push(nb.name.text);
-          }
-        }
-        if (names.length > 0 || isTypeOnly) {
-          imports.push({ names, specifier, isTypeOnly, typeNames });
-        } else if (!clause) {
-          imports.push({ names: [], specifier, isTypeOnly: false, typeNames: /* @__PURE__ */ new Set() });
-        }
-      }
-    }
-    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 });
+  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.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()
-        });
+    } else if (c.name === "jsx.member_tag") {
+      const rootName = c.node.text.split(".")[0];
+      if (rootName && /^[A-Z]/.test(rootName)) {
+        jsxElements.add(rootName);
       }
     }
-    if (ts.isExportAssignment(node) && !node.isExportEquals) {
-      if (ts.isIdentifier(node.expression)) {
-        addExport(node.expression.text, "default");
-      } else {
-        if (!defaultName) defaultName = "default";
-      }
+  }
+  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.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.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.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 linkLiteral = caps["nav.link.literal"] || caps["nav.link.literal.self"];
+    if (linkLiteral) {
+      navigations.push({ kind: "link-href", target: linkLiteral, isTemplate: false });
     }
-    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");
+    const linkTemplate = caps["nav.link.template"] || caps["nav.link.template.self"];
+    if (linkTemplate) {
+      navigations.push({ kind: "link-href", target: linkTemplate, isTemplate: true });
     }
-    if (ts.isTypeAliasDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      addExport(node.name.text, "type");
+    if (caps["nav.window.literal"]) {
+      navigations.push({ kind: "window-location", target: caps["nav.window.literal"], isTemplate: false });
     }
-    if (ts.isInterfaceDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      addExport(node.name.text, "type");
+    if (caps["nav.window.assign.target"]) {
+      navigations.push({ kind: "window-location", target: caps["nav.window.assign.target"], isTemplate: false });
     }
-    if (ts.isEnumDeclaration(node) && hasModifier(node, ts.SyntaxKind.ExportKeyword)) {
-      addExport(node.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"
+      });
     }
-    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 clientUrlTpl = caps["fetch.client.url.template"] || caps["fetch.await.url.template"];
+    const clientMethodTpl = caps["fetch.method.template"] || caps["fetch.await.method.template"];
+    if (clientUrlTpl && clientMethodTpl && templateStartsWithSlash(clientUrlTpl)) {
+      fetchCalls.push({
+        method: clientMethodTpl.toUpperCase(),
+        url: clientUrlTpl,
+        isTemplate: true,
+        kind: "client-method"
+      });
     }
-    if (ts.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
-            });
+  }
+  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.isCallExpression(node) && node.arguments.length > 0) {
-      const expr = node.expression;
-      const firstArg = node.arguments[0];
-      if (ts.isIdentifier(expr) && expr.text === "fetch") {
-        const extracted = extractUrlFromFetchArg(firstArg);
-        if (extracted) {
-          fetchCalls.push({
-            url: extracted.url,
-            isTemplate: extracted.isTemplate,
-            ...extracted.isConcat ? { isConcat: true } : {},
-            kind: "fetch"
-          });
-        }
-      }
-      if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.name)) {
-        const methodName = expr.name.text;
-        if (HTTP_METHODS.has(methodName)) {
-          const extracted = extractUrlFromFetchArg(firstArg);
-          if (extracted) {
-            fetchCalls.push({
-              method: methodName.toUpperCase(),
-              url: extracted.url,
-              isTemplate: extracted.isTemplate,
-              ...extracted.isConcat ? { isConcat: true } : {},
-              kind: "client-method"
-            });
-          }
-        }
-      }
+  }
+  if (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.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 });
-              }
-            }
-          }
-        }
+  }
+  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.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["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.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 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 (caps["ternary.test"]) {
+      conditions.push({
+        kind: "ternary",
+        test: trunc(caps["ternary.test"], 100)
+      });
     }
-    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)
-          });
-        }
-      }
+  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 (caps["var.destructured.obj"]) {
+      variables.push({
+        name: trunc(caps["var.destructured.obj"], 60),
+        kind,
+        init: trunc(caps["var.destructured.init"], 100)
+      });
+    }
+    if (caps["var.array.pattern"]) {
+      variables.push({
+        name: trunc(caps["var.array.pattern"], 60),
+        kind,
+        init: trunc(caps["var.array.init"], 100)
+      });
     }
-    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 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)
+      });
+    }
+  }
+  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 wrappers;
+  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" });
+    }
+  }
+  return { elements, stateVars, conditions, variables, responses, params };
 }
 
 // src/server/graph/parsers/ui/react-nextjs.ts
@@ -744,7 +902,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."));
@@ -758,7 +916,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);
@@ -817,7 +986,7 @@ function generate(rootDir) {
     if (externalScanned.has(normalized)) continue;
     let parsed;
     try {
-      parsed = parseFile(absPath);
+      parsed = parseFileTS(absPath);
     } catch {
       continue;
     }
@@ -941,7 +1110,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;
@@ -980,12 +1149,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, "/");
@@ -1004,6 +1173,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",
@@ -1015,7 +1185,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) {
@@ -1055,7 +1230,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;
       }, {}),
@@ -1910,9 +2085,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"),
@@ -1920,7 +2096,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 {
@@ -1946,7 +2122,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",
@@ -2004,9 +2249,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];
@@ -2017,7 +2266,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) {
@@ -2034,12 +2283,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);
@@ -2048,8 +2295,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;
@@ -2075,7 +2335,7 @@ var moduleTagger = {
         }
       }
       if (matched) continue;
-      const module2 = extractModuleFromPath(id, extraTrivial);
+      const module2 = extractModuleFromPath(id, extraTrivial, extraSkipSegments);
       result.set(id, module2);
     }
     return result;
@@ -2303,7 +2563,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);
@@ -2443,10 +2709,10 @@ function findProjectRoot(startDir) {
   }
   return startDir;
 }
-function buildMergedGraph(projectRoot) {
+async function buildMergedGraph(projectRoot) {
   let graphs = readAllGraphs(projectRoot);
   if (!graphs.ui && !graphs.api && !graphs.db) {
-    generateGraph(projectRoot);
+    await generateGraph(projectRoot);
     graphs = readAllGraphs(projectRoot);
   }
   const nodes = [];
@@ -2556,13 +2822,18 @@ async function startChartServer(opts = {}) {
       const url2 = new URL(req.url ?? "/", `http://${req.headers.host}`);
       if (req.method === "GET" && url2.pathname === "/api/project-graph") {
         const regenerate = url2.searchParams.get("regenerate") === "1";
-        if (regenerate) generateGraph(projectRoot);
-        const merged = buildMergedGraph(projectRoot);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
-          ...merged,
-          debug: { cwd, projectRoot }
-        }));
+        (async () => {
+          if (regenerate) await generateGraph(projectRoot);
+          const merged = await buildMergedGraph(projectRoot);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            ...merged,
+            debug: { cwd, projectRoot }
+          }));
+        })().catch((e) => {
+          res.writeHead(500);
+          res.end(String(e));
+        });
         return;
       }
       if (req.method === "GET" && url2.pathname === "/api/raw-graphs") {
@@ -2572,8 +2843,8 @@ async function startChartServer(opts = {}) {
         return;
       }
       if (req.method === "POST" && url2.pathname === "/api/generate-graph") {
-        try {
-          generateGraph(projectRoot);
+        (async () => {
+          await generateGraph(projectRoot);
           const graphs = readAllGraphs(projectRoot);
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({
@@ -2582,10 +2853,10 @@ async function startChartServer(opts = {}) {
             api: graphs.api ?? null,
             db: graphs.db ?? null
           }));
-        } catch (err) {
+        })().catch((err) => {
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ ok: false, error: String(err) }));
-        }
+        });
         return;
       }
       if (req.method === "GET" && url2.pathname === "/api/file-content") {