@launchsecure/launch-kit 0.0.33 → 0.0.34

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

@@ -1516,6 +1516,7 @@ function emptyParsedFile(absPath) {
   return {
     name: absPath.split("/").pop() ?? absPath,
     exports: [],
+    defines: [],
     imports: [],
     reExports: [],
     jsxElements: /* @__PURE__ */ new Set(),
@@ -1628,6 +1629,34 @@ function parseFileTS(absPath) {
       reExports.push({ name: "*", from: caps["reexport.wildcard.source"], isWildcard: true });
     }
   }
+  const definesSet = /* @__PURE__ */ new Set();
+  function recordCallable(decl) {
+    if (decl.type === "function_declaration" || decl.type === "generator_function_declaration") {
+      const id = childOfType(decl, "identifier");
+      if (id) definesSet.add(id.text);
+      return;
+    }
+    if (decl.type === "class_declaration") {
+      const id = childOfType(decl, "type_identifier") ?? childOfType(decl, "identifier");
+      if (id) definesSet.add(id.text);
+      return;
+    }
+    if (decl.type === "lexical_declaration" || decl.type === "variable_declaration") {
+      for (const d of childrenOfType(decl, "variable_declarator")) {
+        const id = childOfType(d, "identifier");
+        if (!id) continue;
+        const isCallable = !!childOfType(d, "arrow_function") || !!childOfType(d, "function_expression") || !!childOfType(d, "function") || !!childOfType(d, "generator_function");
+        if (isCallable) definesSet.add(id.text);
+      }
+    }
+  }
+  for (const child of root.children) {
+    if (child.type === "export_statement") {
+      for (const gc of child.children) recordCallable(gc);
+    } else {
+      recordCallable(child);
+    }
+  }
   const jsxElements = /* @__PURE__ */ new Set();
   const jsxQuery = getQuery("jsx-elements");
   const jsxCaptures = jsxQuery.captures(root);
@@ -1716,7 +1745,7 @@ function parseFileTS(absPath) {
     }
   }
   const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
-  return { name, exports: exportsOrdered, imports, reExports, jsxElements, navigations, fetchCalls };
+  return { name, exports: exportsOrdered, defines: [...definesSet], imports, reExports, jsxElements, navigations, fetchCalls };
 }
 function extractDbCallsTS(absPath) {
   const tree = parseSource(absPath);
@@ -2933,6 +2962,11 @@ function generate(rootDir) {
     const parsed = parsedByPath.get(absPath);
     const name = parsed.name || nameFromFilename(absPath);
     const layer = CLASSIFICATION_TO_LAYER[type] ?? "ui";
+    const importedNames = [...new Set(
+      parsed.imports.flatMap(
+        (imp) => imp.isTypeOnly ? [] : imp.names.filter((n) => !imp.typeNames.has(n))
+      )
+    )];
     nodeIdSet.add(id);
     if (layer === "api") {
       const dbCalls = extractDbCallsTS(absPath);
@@ -2971,6 +3005,8 @@ function generate(rootDir) {
         responses: deep.responses,
         params: deep.params,
         ...deep.effects ? { effects: deep.effects } : {},
+        ...parsed.defines.length > 0 ? { defines: parsed.defines } : {},
+        ...importedNames.length > 0 ? { imported_names: importedNames } : {},
         ...deep.notes ? { notes: deep.notes } : {},
         _dbCalls: dbCalls
         // temp: used for cross-ref building below
@@ -2987,6 +3023,8 @@ function generate(rootDir) {
         layer: "ui",
         route,
         exports: parsed.exports,
+        ...parsed.defines.length > 0 ? { defines: parsed.defines } : {},
+        ...importedNames.length > 0 ? { imported_names: importedNames } : {},
         elements: deep.elements,
         stateVars: deep.stateVars,
         conditions: deep.conditions,
@@ -6041,6 +6079,138 @@ var init_middleware_gates = __esm({
   }
 });
 
+// src/server/graph/parsers/crosslayer/call-resolver.ts
+var BARE_IDENT, callResolverParser;
+var init_call_resolver = __esm({
+  "src/server/graph/parsers/crosslayer/call-resolver.ts"() {
+    "use strict";
+    BARE_IDENT = /^[A-Za-z_$][\w$]*$/;
+    callResolverParser = {
+      id: "call-resolver",
+      layer: "crosslayer",
+      concern: "call-graph",
+      detect(_rootDir) {
+        return true;
+      },
+      generate(_rootDir, layerOutputs) {
+        const definers = /* @__PURE__ */ new Map();
+        const addDef = (sym, entry) => {
+          if (!BARE_IDENT.test(sym)) return;
+          const list = definers.get(sym);
+          if (!list) {
+            definers.set(sym, [entry]);
+          } else if (!list.some((d) => d.nodeId === entry.nodeId)) {
+            list.push(entry);
+          }
+        };
+        const nodeLayer = /* @__PURE__ */ new Map();
+        for (const [layer, output] of layerOutputs) {
+          if (layer === "db" || layer === "static") continue;
+          for (const node of output.nodes) {
+            nodeLayer.set(node.id, layer);
+            const entry = { nodeId: node.id, layer };
+            for (const s of node.exports ?? []) addDef(s, entry);
+            for (const s of node.defines ?? []) addDef(s, entry);
+          }
+        }
+        const importTargets = /* @__PURE__ */ new Map();
+        for (const [, output] of layerOutputs) {
+          for (const e of output.edges) {
+            if (e.type !== "imports" && e.type !== "imports_type" && e.type !== "renders") continue;
+            let set = importTargets.get(e.source);
+            if (!set) {
+              set = /* @__PURE__ */ new Set();
+              importTargets.set(e.source, set);
+            }
+            set.add(e.target);
+          }
+        }
+        const crossRefs = [];
+        const seen = /* @__PURE__ */ new Set();
+        let resolvedSelf = 0;
+        let resolvedImport = 0;
+        let ambiguous = 0;
+        let dropped = 0;
+        for (const [, output] of layerOutputs) {
+          for (const node of output.nodes) {
+            const calls = node.effects?.calls;
+            if (!calls || calls.length === 0) continue;
+            const selfSyms = /* @__PURE__ */ new Set([
+              ...node.exports ?? [],
+              ...node.defines ?? []
+            ]);
+            const importedSyms = new Set(node.imported_names ?? []);
+            const myImports = importTargets.get(node.id);
+            const localSeen = /* @__PURE__ */ new Set();
+            for (const callee of calls) {
+              if (!BARE_IDENT.test(callee)) continue;
+              if (localSeen.has(callee)) continue;
+              localSeen.add(callee);
+              const key = `${node.id}\u2192${callee}`;
+              if (selfSyms.has(callee)) {
+                if (seen.has(key)) continue;
+                seen.add(key);
+                crossRefs.push({
+                  source: node.id,
+                  target: callee,
+                  type: "calls",
+                  layer: nodeLayer.get(node.id) ?? "ui",
+                  defined_in: node.id
+                });
+                resolvedSelf++;
+                continue;
+              }
+              if (!importedSyms.has(callee)) {
+                dropped++;
+                continue;
+              }
+              const defs = (definers.get(callee) ?? []).filter((d) => d.nodeId !== node.id);
+              if (defs.length === 0) {
+                dropped++;
+                continue;
+              }
+              const fromImported = myImports ? defs.filter((d) => myImports.has(d.nodeId)) : [];
+              const chosen = fromImported.length > 0 ? fromImported : defs;
+              const owner = chosen[0];
+              const isAmbiguous = chosen.length > 1;
+              if (isAmbiguous) ambiguous++;
+              if (seen.has(key)) continue;
+              seen.add(key);
+              const ref = {
+                source: node.id,
+                target: callee,
+                type: "calls",
+                layer: owner.layer,
+                defined_in: owner.nodeId
+              };
+              if (isAmbiguous) ref.ambiguous = true;
+              crossRefs.push(ref);
+              resolvedImport++;
+            }
+          }
+        }
+        crossRefs.sort(
+          (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target)
+        );
+        return {
+          cross_refs: crossRefs,
+          flagged_edges: [],
+          warnings: [],
+          patterns: {
+            call_resolution: {
+              resolved_self: resolvedSelf,
+              resolved_import: resolvedImport,
+              ambiguous,
+              dropped,
+              symbols_defined: definers.size
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
 // src/server/graph/core/parser-registry.ts
 function isMultiLayerParser(p) {
   return "layers" in p && Array.isArray(p.layers);
@@ -6055,7 +6225,8 @@ function registerBuiltins2(registry, disabled) {
     apiAnnotationsParser,
     urlLiteralScannerParser,
     staticRefScannerParser,
-    middlewareGatesParser
+    middlewareGatesParser,
+    callResolverParser
   ];
   for (const parser of builtins) {
     if (disabled.has(parser.id)) continue;
@@ -6106,6 +6277,7 @@ var init_parser_registry = __esm({
     init_static_values();
     init_static_ref_scanner();
     init_middleware_gates();
+    init_call_resolver();
     ParserRegistry = class {
       constructor() {
         this.singleLayerParsers = /* @__PURE__ */ new Map();
@@ -7607,14 +7779,14 @@ Regenerated ${okCount}/${projects.length} project graph(s)${failCount ? ` (${fai
       }
       const graph = readGraph(rootDir, layer);
       if (!graph) {
-        console.error(`No ${layer} graph found. Run: launchpod graph:generate${projectArg ? ` --project ${projectArg}` : ""}`);
+        console.error(`No ${layer} graph found. Run: launch-sequencer graph:generate${projectArg ? ` --project ${projectArg}` : ""}`);
         process.exit(1);
       }
       console.log(JSON.stringify(graph, null, 2));
     } else {
       const graphs = readAllGraphs(rootDir);
       if (Object.keys(graphs).length === 0) {
-        console.error(`No graphs found. Run: launchpod graph:generate${projectArg ? ` --project ${projectArg}` : ""}`);
+        console.error(`No graphs found. Run: launch-sequencer graph:generate${projectArg ? ` --project ${projectArg}` : ""}`);
         process.exit(1);
       }
       console.log(JSON.stringify(graphs, null, 2));
@@ -9363,6 +9535,10 @@ function handleWhoUses(args) {
       };
       const via = cr.via;
       if (Array.isArray(via)) entry.via = via;
+      const definedIn = cr.defined_in;
+      if (typeof definedIn === "string") entry.defined_in = definedIn;
+      const ambiguous = cr.ambiguous;
+      if (ambiguous) entry.ambiguous = true;
       hits.push(entry);
     }
   }