@posthog/agent 2.3.363 → 2.3.370

package/dist/server/agent-server.js

@@ -809,15 +809,15 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path15, isFile, isDirectory) {
+    function check(path15, isFile2, isDirectory) {
       log(`checking %s`, path15);
       try {
-        const stat = fs_1.statSync(path15);
-        if (stat.isFile() && isFile) {
+        const stat2 = fs_1.statSync(path15);
+        if (stat2.isFile() && isFile2) {
           log(`[OK] path represents a file`);
           return true;
         }
-        if (stat.isDirectory() && isDirectory) {
+        if (stat2.isDirectory() && isDirectory) {
           log(`[OK] path represents a directory`);
           return true;
         }
@@ -947,10 +947,10 @@ var require_tree_sitter = __commonJS({
               };
               readAsync = (filename, binary2 = true) => {
                 filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
-                return new Promise((resolve4, reject) => {
+                return new Promise((resolve6, reject) => {
                   fs.readFile(filename, binary2 ? void 0 : "utf8", (err2, data) => {
                     if (err2) reject(err2);
-                    else resolve4(binary2 ? data.buffer : data);
+                    else resolve6(binary2 ? data.buffer : data);
                   });
                 });
               };
@@ -991,13 +991,13 @@ var require_tree_sitter = __commonJS({
                 }
                 readAsync = (url) => {
                   if (isFileURI(url)) {
-                    return new Promise((reject, resolve4) => {
+                    return new Promise((reject, resolve6) => {
                       var xhr = new XMLHttpRequest();
                       xhr.open("GET", url, true);
                       xhr.responseType = "arraybuffer";
                       xhr.onload = () => {
                         if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                          resolve4(xhr.response);
+                          resolve6(xhr.response);
                         }
                         reject(xhr.status);
                       };
@@ -1957,8 +1957,8 @@ var require_tree_sitter = __commonJS({
                 }
                 var libFile = locateFile(libName2);
                 if (flags2.loadAsync) {
-                  return new Promise(function(resolve4, reject) {
-                    asyncLoad(libFile, resolve4, reject);
+                  return new Promise(function(resolve6, reject) {
+                    asyncLoad(libFile, resolve6, reject);
                   });
                 }
                 if (!readBinary) {
@@ -3785,7 +3785,7 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 
 // src/server/agent-server.ts
 import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
-import { basename as basename2, join as join11 } from "path";
+import { basename as basename2, join as join12 } from "path";
 import { pathToFileURL } from "url";
 import {
   ClientSideConnection as ClientSideConnection2,
@@ -8374,10 +8374,10 @@ async function getIndexLockPath(repoPath) {
 async function getLockInfo(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
   try {
-    const stat = await fs2.stat(lockPath);
+    const stat2 = await fs2.stat(lockPath);
     return {
       path: lockPath,
-      ageMs: Date.now() - stat.mtimeMs
+      ageMs: Date.now() - stat2.mtimeMs
     };
   } catch {
     return null;
@@ -8412,10 +8412,10 @@ var AsyncReaderWriterLock = class {
       this.readers++;
       return;
     }
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       this.readQueue.push(() => {
         this.readers++;
-        resolve4();
+        resolve6();
       });
     });
   }
@@ -8429,11 +8429,11 @@ var AsyncReaderWriterLock = class {
       return;
     }
     this.writerWaiting = true;
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       this.writeQueue.push(() => {
         this.writerWaiting = this.writeQueue.length > 0;
         this.writer = true;
-        resolve4();
+        resolve6();
       });
     });
   }
@@ -8605,7 +8605,7 @@ import { z as z4 } from "zod";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.363",
+  version: "2.3.370",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -8860,17 +8860,17 @@ var Pushable = class {
   resolvers = [];
   done = false;
   push(item) {
-    const resolve4 = this.resolvers.shift();
-    if (resolve4) {
-      resolve4({ value: item, done: false });
+    const resolve6 = this.resolvers.shift();
+    if (resolve6) {
+      resolve6({ value: item, done: false });
     } else {
       this.queue.push(item);
     }
   }
   end() {
     this.done = true;
-    for (const resolve4 of this.resolvers) {
-      resolve4({ value: void 0, done: true });
+    for (const resolve6 of this.resolvers) {
+      resolve6({ value: void 0, done: true });
     }
     this.resolvers = [];
   }
@@ -8887,8 +8887,8 @@ var Pushable = class {
             done: true
           });
         }
-        return new Promise((resolve4) => {
-          this.resolvers.push(resolve4);
+        return new Promise((resolve6) => {
+          this.resolvers.push(resolve6);
         });
       }
     };
@@ -9002,20 +9002,20 @@ function nodeReadableToWebReadable(nodeStream) {
 function nodeWritableToWebWritable(nodeStream) {
   return new WritableStream2({
     write(chunk) {
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve6, reject) => {
         const ok = nodeStream.write(Buffer.from(chunk), (err2) => {
           if (err2) reject(err2);
         });
         if (ok) {
-          resolve4();
+          resolve6();
         } else {
-          nodeStream.once("drain", resolve4);
+          nodeStream.once("drain", resolve6);
         }
       });
     },
     close() {
-      return new Promise((resolve4) => {
-        nodeStream.end(resolve4);
+      return new Promise((resolve6) => {
+        nodeStream.end(resolve6);
       });
     },
     abort(reason) {
@@ -9046,11 +9046,13 @@ import * as path4 from "path";
 
 // ../enricher/dist/index.js
 var import_web_tree_sitter = __toESM(require_tree_sitter(), 1);
-import { existsSync } from "fs";
+import { statSync } from "fs";
 import * as path3 from "path";
+import { existsSync } from "fs";
+import * as path22 from "path";
 import { fileURLToPath } from "url";
 import * as fs4 from "fs/promises";
-import * as path22 from "path";
+import * as path32 from "path";
 function getCapture(captures, name2) {
   const found = captures.find((c) => c.name === name2);
   return found ? found.node : null;
@@ -9165,6 +9167,22 @@ function walkNodes(root, type, callback) {
   };
   visit(root);
 }
+var JSX_NODE_TYPES = /* @__PURE__ */ new Set([
+  "jsx_element",
+  "jsx_fragment",
+  "jsx_self_closing_element",
+  "jsx_opening_element",
+  "jsx_closing_element",
+  "jsx_attribute"
+]);
+function isInsideJsx(node) {
+  let cur = node.parent;
+  while (cur) {
+    if (JSX_NODE_TYPES.has(cur.type)) return true;
+    cur = cur.parent;
+  }
+  return false;
+}
 var JS_CAPTURE_METHODS = /* @__PURE__ */ new Set(["capture"]);
 var JS_FLAG_METHODS = /* @__PURE__ */ new Set([
   "getFeatureFlag",
@@ -9350,6 +9368,33 @@ var JS_QUERIES = {
         object: (_) @client
         property: (property_identifier) @method)
       arguments: (arguments . (_) @first_arg)) @call
+  `,
+  imports: `
+    (import_statement
+      (import_clause
+        (identifier) @default_name)
+      source: (string (string_fragment) @source)) @stmt
+
+    (import_statement
+      (import_clause
+        (named_imports
+          (import_specifier
+            name: (identifier) @imported_name) @spec))
+      source: (string (string_fragment) @source)) @stmt
+
+    (import_statement
+      (import_clause
+        (named_imports
+          (import_specifier
+            name: (identifier) @imported_name
+            alias: (identifier) @local_name) @spec))
+      source: (string (string_fragment) @source)) @stmt
+
+    (import_statement
+      (import_clause
+        (namespace_import
+          (identifier) @namespace_name))
+      source: (string (string_fragment) @source)) @stmt
   `
 };
 var PY_QUERIES = {
@@ -9426,6 +9471,31 @@ var PY_QUERIES = {
         object: (_) @client
         attribute: (identifier) @method)
       arguments: (argument_list . (_) @first_arg)) @call
+  `,
+  imports: `
+    (import_from_statement
+      module_name: (dotted_name) @source
+      name: (dotted_name) @imported_name) @stmt
+
+    (import_from_statement
+      module_name: (dotted_name) @source
+      name: (aliased_import
+        name: (dotted_name) @imported_name
+        alias: (identifier) @local_name)) @stmt
+
+    (import_from_statement
+      module_name: (relative_import
+        (import_prefix) @relative_prefix
+        (dotted_name)? @relative_name)
+      name: (dotted_name) @imported_name) @stmt
+
+    (import_from_statement
+      module_name: (relative_import
+        (import_prefix) @relative_prefix
+        (dotted_name)? @relative_name)
+      name: (aliased_import
+        name: (dotted_name) @imported_name
+        alias: (identifier) @local_name)) @stmt
   `
 };
 var GO_QUERIES = {
@@ -9817,7 +9887,7 @@ function buildConstantMap(pm, lang, tree) {
 }
 var POSTHOG_CLASS_NAMES2 = /* @__PURE__ */ new Set(["PostHog", "Posthog"]);
 var GO_CONSTRUCTOR_NAMES2 = /* @__PURE__ */ new Set(["New", "NewWithConfig"]);
-async function findPostHogCalls(pm, source, languageId) {
+async function findPostHogCalls(pm, source, languageId, context) {
   const ready = await pm.ensureReady(languageId);
   if (!ready) {
     return [];
@@ -9846,6 +9916,7 @@ async function findPostHogCalls(pm, source, languageId) {
       const clientNode = getCapture(match.captures, "client");
       const methodNode = getCapture(match.captures, "method");
       const keyNode = getCapture(match.captures, "key");
+      const callNode = getCapture(match.captures, "call");
       if (!clientNode || !methodNode || !keyNode) {
         continue;
       }
@@ -9871,7 +9942,8 @@ async function findPostHogCalls(pm, source, languageId) {
         key: cleanStringValue(keyNode.text),
         line: keyNode.startPosition.row,
         keyStartCol: keyNode.startPosition.column,
-        keyEndCol: keyNode.endPosition.column
+        keyEndCol: keyNode.endPosition.column,
+        inJsx: callNode ? isInsideJsx(callNode) : void 0
       });
     }
   }
@@ -9926,6 +9998,7 @@ async function findPostHogCalls(pm, source, languageId) {
       const methodNode = getCapture(match.captures, "method");
       const propNameNode = getCapture(match.captures, "prop_name");
       const keyNode = getCapture(match.captures, "key");
+      const callNode = getCapture(match.captures, "call");
       if (!clientNode || !methodNode || !propNameNode || !keyNode) {
         continue;
       }
@@ -9948,7 +10021,8 @@ async function findPostHogCalls(pm, source, languageId) {
         key: cleanStringValue(keyNode.text),
         line: keyNode.startPosition.row,
         keyStartCol: keyNode.startPosition.column,
-        keyEndCol: keyNode.endPosition.column
+        keyEndCol: keyNode.endPosition.column,
+        inJsx: callNode ? isInsideJsx(callNode) : void 0
       });
     }
   }
@@ -10045,6 +10119,7 @@ async function findPostHogCalls(pm, source, languageId) {
       for (const match of matches) {
         const funcNode = getCapture(match.captures, "func_name");
         const keyNode = getCapture(match.captures, "key");
+        const callNode = getCapture(match.captures, "call");
         if (!funcNode || !keyNode) {
           continue;
         }
@@ -10055,7 +10130,8 @@ async function findPostHogCalls(pm, source, languageId) {
             key: cleanStringValue(keyNode.text),
             line: keyNode.startPosition.row,
             keyStartCol: keyNode.startPosition.column,
-            keyEndCol: keyNode.endPosition.column
+            keyEndCol: keyNode.endPosition.column,
+            inJsx: callNode ? isInsideJsx(callNode) : void 0
           });
         }
       }
@@ -10069,6 +10145,7 @@ async function findPostHogCalls(pm, source, languageId) {
       for (const match of matches) {
         const funcNode = getCapture(match.captures, "func_name");
         const keyNode = getCapture(match.captures, "key");
+        const callNode = getCapture(match.captures, "call");
         if (!funcNode || !keyNode) {
           continue;
         }
@@ -10078,7 +10155,8 @@ async function findPostHogCalls(pm, source, languageId) {
             key: cleanStringValue(keyNode.text),
             line: keyNode.startPosition.row,
             keyStartCol: keyNode.startPosition.column,
-            keyEndCol: keyNode.endPosition.column
+            keyEndCol: keyNode.endPosition.column,
+            inJsx: callNode ? isInsideJsx(callNode) : void 0
           });
         }
       }
@@ -10093,6 +10171,7 @@ async function findPostHogCalls(pm, source, languageId) {
         const clientNode = getCapture(match.captures, "client");
         const methodNode = getCapture(match.captures, "method");
         const argNode = getCapture(match.captures, "arg_id");
+        const callNode = getCapture(match.captures, "call");
         if (!clientNode || !methodNode || !argNode) {
           continue;
         }
@@ -10122,7 +10201,8 @@ async function findPostHogCalls(pm, source, languageId) {
           key: resolved,
           line,
           keyStartCol: argNode.startPosition.column,
-          keyEndCol: argNode.endPosition.column
+          keyEndCol: argNode.endPosition.column,
+          inJsx: callNode ? isInsideJsx(callNode) : void 0
         });
       }
     }
@@ -10135,6 +10215,7 @@ async function findPostHogCalls(pm, source, languageId) {
       const clientNode = getCapture(match.captures, "client");
       const methodNode = getCapture(match.captures, "method");
       const firstArgNode = getCapture(match.captures, "first_arg");
+      const callNode = getCapture(match.captures, "call");
       if (!clientNode || !methodNode || !firstArgNode) {
         continue;
       }
@@ -10159,13 +10240,167 @@ async function findPostHogCalls(pm, source, languageId) {
         line,
         keyStartCol: firstArgNode.startPosition.column,
         keyEndCol: firstArgNode.endPosition.column,
-        dynamic: true
+        dynamic: true,
+        inJsx: callNode ? isInsideJsx(callNode) : void 0
       });
       matchedLines.add(line);
     }
   }
+  if (context?.wrappersByLocalName?.size) {
+    synthesizeBareWrapperCalls(
+      pm,
+      lang,
+      tree,
+      languageId,
+      context.wrappersByLocalName,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
+  if (context?.namespaceWrappers?.size) {
+    synthesizeNamespaceWrapperCalls(
+      pm,
+      lang,
+      tree,
+      languageId,
+      context.namespaceWrappers,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
   return calls;
 }
+var WRAPPER_BARE_CALL_QUERIES = {
+  javascript: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  javascriptreact: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  typescript: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  typescriptreact: `(call_expression function: (identifier) @func_name arguments: (arguments) @args) @call`,
+  python: `(call function: (identifier) @func_name arguments: (argument_list) @args) @call`
+};
+var WRAPPER_NAMESPACE_CALL_QUERIES = {
+  javascript: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  javascriptreact: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  typescript: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  typescriptreact: `(call_expression function: (member_expression object: (identifier) @ns property: (property_identifier) @method) arguments: (arguments) @args) @call`,
+  python: `(call function: (attribute object: (identifier) @ns attribute: (identifier) @method) arguments: (argument_list) @args) @call`
+};
+function synthesizeBareWrapperCalls(pm, lang, tree, languageId, wrappers, constantMap, calls, matchedLines) {
+  const queryStr = WRAPPER_BARE_CALL_QUERIES[languageId];
+  if (!queryStr) return;
+  const query2 = pm.getQuery(lang, queryStr);
+  if (!query2) return;
+  for (const match of query2.matches(tree.rootNode)) {
+    const funcNode = getCapture(match.captures, "func_name");
+    const argsNode = getCapture(match.captures, "args");
+    const callNode = getCapture(match.captures, "call");
+    if (!funcNode || !argsNode) continue;
+    const wrapper = wrappers.get(funcNode.text);
+    if (!wrapper) continue;
+    pushWrapperCall(
+      wrapper,
+      funcNode,
+      argsNode,
+      callNode,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
+}
+function synthesizeNamespaceWrapperCalls(pm, lang, tree, languageId, namespaceWrappers, constantMap, calls, matchedLines) {
+  const queryStr = WRAPPER_NAMESPACE_CALL_QUERIES[languageId];
+  if (!queryStr) return;
+  const query2 = pm.getQuery(lang, queryStr);
+  if (!query2) return;
+  for (const match of query2.matches(tree.rootNode)) {
+    const nsNode = getCapture(match.captures, "ns");
+    const methodNode = getCapture(match.captures, "method");
+    const argsNode = getCapture(match.captures, "args");
+    const callNode = getCapture(match.captures, "call");
+    if (!nsNode || !methodNode || !argsNode) continue;
+    const nsWrappers = namespaceWrappers.get(nsNode.text);
+    if (!nsWrappers) continue;
+    const wrapper = nsWrappers.get(methodNode.text);
+    if (!wrapper) continue;
+    pushWrapperCall(
+      wrapper,
+      methodNode,
+      argsNode,
+      callNode,
+      constantMap,
+      calls,
+      matchedLines
+    );
+  }
+}
+function pushWrapperCall(wrapper, callerNode, argsNode, callNode, constantMap, calls, matchedLines) {
+  let line = callerNode.startPosition.row;
+  let keyStartCol = callerNode.startPosition.column;
+  let keyEndCol = callerNode.endPosition.column;
+  let key = "";
+  let dynamic = false;
+  if (wrapper.classification.kind === "fixed-key") {
+    key = wrapper.classification.key;
+  } else {
+    const positional = argsNode.namedChildren.filter(
+      (c) => c.type !== "comment" && c.type !== "keyword_argument"
+    );
+    const arg = positional[wrapper.classification.paramIndex];
+    if (!arg) return;
+    line = arg.startPosition.row;
+    keyStartCol = arg.startPosition.column;
+    keyEndCol = arg.endPosition.column;
+    if (arg.type === "string") {
+      const fragment = arg.namedChildren.find(
+        (c) => c.type === "string_fragment" || c.type === "string_content"
+      );
+      if (fragment) {
+        key = fragment.text;
+      } else {
+        dynamic = true;
+      }
+    } else if (arg.type === "template_string") {
+      const fragments = arg.namedChildren.filter(
+        (c) => c.type === "string_fragment"
+      );
+      const hasInterp = arg.namedChildren.some(
+        (c) => c.type === "template_substitution"
+      );
+      if (!hasInterp && fragments.length === 1) {
+        key = fragments[0].text;
+      } else {
+        dynamic = true;
+      }
+    } else if (arg.type === "interpreted_string_literal") {
+      key = arg.text.slice(1, -1);
+    } else if (arg.type === "identifier") {
+      const resolved = constantMap.get(arg.text);
+      if (resolved) {
+        key = resolved;
+      } else {
+        dynamic = true;
+      }
+    } else {
+      dynamic = true;
+    }
+  }
+  if (matchedLines.has(line) && dynamic) {
+    return;
+  }
+  calls.push({
+    method: wrapper.posthogMethod,
+    key,
+    line,
+    keyStartCol,
+    keyEndCol,
+    dynamic: dynamic ? true : void 0,
+    viaWrapper: wrapper.name,
+    inJsx: callNode ? isInsideJsx(callNode) : void 0
+  });
+  matchedLines.add(line);
+}
 async function findInitCalls(pm, source, languageId) {
   const ready = await pm.ensureReady(languageId);
   if (!ready) {
@@ -10578,6 +10813,7 @@ async function findFunctions(pm, source, languageId) {
     }
     const params = singleParamNode ? [singleParamNode.text] : paramsNode ? extractParams(paramsNode.text) : [];
     const bodyLine = bodyNode.startPosition.row;
+    const bodyEndLine = bodyNode.endPosition.row;
     const nextLineIdx = bodyLine + 1;
     const lines = text2.split("\n");
     const nextLine = nextLineIdx < lines.length ? lines[nextLineIdx] : "";
@@ -10587,6 +10823,7 @@ async function findFunctions(pm, source, languageId) {
       params,
       isComponent: /^[A-Z]/.test(name2),
       bodyLine,
+      bodyEndLine,
       bodyIndent
     });
   }
@@ -10644,6 +10881,157 @@ async function findFlagAssignments(pm, source, languageId) {
   }
   return assignments;
 }
+var JS_EXTENSION_PROBES = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+];
+var PY_EXTENSION_PROBES = [".py"];
+function isRelativeSpecifier(spec) {
+  return spec.startsWith("./") || spec.startsWith("../") || spec === ".";
+}
+function resolveJsPath(callerAbsPath, specifier) {
+  if (!isRelativeSpecifier(specifier)) return null;
+  const dir = path3.dirname(callerAbsPath);
+  const base = path3.resolve(dir, specifier);
+  if (JS_EXTENSION_PROBES.includes(path3.extname(specifier))) {
+    return isFile(base) ? base : null;
+  }
+  if (isFile(base)) return base;
+  for (const ext of JS_EXTENSION_PROBES) {
+    const candidate = base + ext;
+    if (isFile(candidate)) return candidate;
+  }
+  for (const ext of JS_EXTENSION_PROBES) {
+    const candidate = path3.join(base, `index${ext}`);
+    if (isFile(candidate)) return candidate;
+  }
+  return null;
+}
+function isFile(p) {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolvePythonModule(callerAbsPath, relativePrefix, moduleName) {
+  if (!relativePrefix) return null;
+  const dots = relativePrefix.length;
+  const levelsUp = dots - 1;
+  let baseDir = path3.dirname(callerAbsPath);
+  for (let i2 = 0; i2 < levelsUp; i2++) {
+    baseDir = path3.dirname(baseDir);
+  }
+  if (!moduleName) {
+    const init2 = path3.join(baseDir, "__init__.py");
+    return isFile(init2) ? init2 : null;
+  }
+  const parts2 = moduleName.split(".");
+  const joined = path3.join(baseDir, ...parts2);
+  for (const ext of PY_EXTENSION_PROBES) {
+    const candidate = joined + ext;
+    if (isFile(candidate)) return candidate;
+  }
+  const pkgInit = path3.join(joined, "__init__.py");
+  if (isFile(pkgInit)) return pkgInit;
+  return null;
+}
+async function findImports(pm, source, languageId, callerAbsPath) {
+  const ready = await pm.ensureReady(languageId);
+  if (!ready) return [];
+  const { lang, family } = ready;
+  if (!family.queries.imports) return [];
+  const tree = pm.parse(source, lang);
+  if (!tree) return [];
+  const query2 = pm.getQuery(lang, family.queries.imports);
+  if (!query2) return [];
+  const edges = [];
+  const isPython = languageId === "python";
+  for (const match of query2.matches(tree.rootNode)) {
+    if (isPython) {
+      pushPythonEdge(match.captures, callerAbsPath, edges);
+    } else {
+      pushJsEdge(match.captures, callerAbsPath, edges);
+    }
+  }
+  return dedupe(edges);
+}
+function pushJsEdge(captures, callerAbsPath, out2) {
+  const sourceNode = getCapture(captures, "source");
+  if (!sourceNode) return;
+  const specifier = sourceNode.text;
+  if (!isRelativeSpecifier(specifier)) return;
+  const resolvedAbsPath = resolveJsPath(callerAbsPath, specifier);
+  const defaultNode = getCapture(captures, "default_name");
+  if (defaultNode) {
+    out2.push({
+      localName: defaultNode.text,
+      importedName: "default",
+      isDefault: true,
+      resolvedAbsPath
+    });
+    return;
+  }
+  const namespaceNode = getCapture(captures, "namespace_name");
+  if (namespaceNode) {
+    out2.push({
+      localName: namespaceNode.text,
+      importedName: "*",
+      isNamespace: true,
+      resolvedAbsPath
+    });
+    return;
+  }
+  const importedNode = getCapture(captures, "imported_name");
+  if (importedNode) {
+    const localNode = getCapture(captures, "local_name");
+    out2.push({
+      localName: (localNode ?? importedNode).text,
+      importedName: importedNode.text,
+      resolvedAbsPath
+    });
+  }
+}
+function pushPythonEdge(captures, callerAbsPath, out2) {
+  const importedNode = getCapture(captures, "imported_name");
+  if (!importedNode) return;
+  const relativePrefix = getCapture(captures, "relative_prefix");
+  const relativeName = getCapture(captures, "relative_name");
+  const sourceNode = getCapture(captures, "source");
+  let resolvedAbsPath = null;
+  if (relativePrefix) {
+    resolvedAbsPath = resolvePythonModule(
+      callerAbsPath,
+      relativePrefix.text,
+      relativeName ? relativeName.text : null
+    );
+  } else if (sourceNode) {
+    resolvedAbsPath = resolvePythonModule(callerAbsPath, ".", sourceNode.text);
+  }
+  const localNode = getCapture(captures, "local_name");
+  out2.push({
+    localName: (localNode ?? importedNode).text,
+    importedName: importedNode.text,
+    resolvedAbsPath
+  });
+}
+function dedupe(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const out2 = [];
+  for (const e of edges) {
+    const key = `${e.localName}|${e.importedName}|${e.resolvedAbsPath ?? ""}|${e.isDefault ? "d" : ""}|${e.isNamespace ? "n" : ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out2.push(e);
+  }
+  return out2;
+}
 var noop = {
   warn() {
   }
@@ -10659,17 +11047,18 @@ var DEFAULT_CONFIG = {
 };
 function resolveGrammarsDir() {
   const thisFile = fileURLToPath(import.meta.url);
-  const dir = path3.dirname(thisFile);
+  const dir = path22.dirname(thisFile);
   const candidates = [
-    path3.join(dir, "..", "grammars"),
-    path3.join(dir, "grammars"),
-    path3.join(dir, "..", "..", "grammars")
+    path22.join(dir, "..", "grammars"),
+    path22.join(dir, "grammars"),
+    path22.join(dir, "..", "..", "grammars")
   ];
   return candidates.find((p) => existsSync(p)) ?? candidates[0];
 }
 var ParserManager = class {
   parser = null;
   languages = /* @__PURE__ */ new Map();
+  languageKeys = /* @__PURE__ */ new WeakMap();
   queryCache = /* @__PURE__ */ new Map();
   maxCacheSize = 256;
   initPromise = null;
@@ -10688,7 +11077,7 @@ var ParserManager = class {
   async doInit() {
     try {
       await import_web_tree_sitter.default.init({
-        locateFile: (scriptName) => path3.join(this.wasmDir, scriptName)
+        locateFile: (scriptName) => path22.join(this.wasmDir, scriptName)
       });
       this.parser = new import_web_tree_sitter.default();
     } catch (err2) {
@@ -10715,9 +11104,10 @@ var ParserManager = class {
     let lang = this.languages.get(family.wasm);
     if (!lang) {
       try {
-        const wasmPath = path3.join(this.wasmDir, family.wasm);
+        const wasmPath = path22.join(this.wasmDir, family.wasm);
         lang = await import_web_tree_sitter.default.Language.load(wasmPath);
         this.languages.set(family.wasm, lang);
+        this.languageKeys.set(lang, family.wasm);
       } catch (err2) {
         warn(`Failed to load grammar ${family.wasm}`, err2);
         return null;
@@ -10736,7 +11126,8 @@ var ParserManager = class {
     if (!queryStr.trim()) {
       return null;
     }
-    const cacheKey = `${lang.toString()}:${queryStr}`;
+    const langKey = this.languageKeys.get(lang) ?? lang.toString();
+    const cacheKey = `${langKey}:${queryStr}`;
     let query2 = this.queryCache.get(cacheKey);
     if (query2) {
       this.queryCache.delete(cacheKey);
@@ -10763,6 +11154,7 @@ var ParserManager = class {
     this.parser = null;
     this.initPromise = null;
     this.languages.clear();
+    this.languageKeys = /* @__PURE__ */ new WeakMap();
     this.queryCache.clear();
   }
 };
@@ -11577,6 +11969,260 @@ function isTruthinessCheckForVar(conditionNode, varName) {
   }
   return false;
 }
+var CONTROL_FLOW_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "catch",
+  "else"
+]);
+function getKeyArgLocator(method, family, languageId) {
+  if (languageId === "python") {
+    if (family.captureMethods.has(method)) {
+      return { positionalIndex: 1, kwargName: "event" };
+    }
+    if (family.flagMethods.has(method)) {
+      return { positionalIndex: 0, kwargName: "key" };
+    }
+    return null;
+  }
+  if (family.allMethods.has(method)) {
+    return { positionalIndex: 0 };
+  }
+  return null;
+}
+function extractRawParams(paramsNode, singleParamNode, languageId) {
+  if (singleParamNode) {
+    return [singleParamNode.text];
+  }
+  if (!paramsNode) {
+    return [];
+  }
+  const names = [];
+  for (const child of paramsNode.namedChildren) {
+    const n = extractParamName(child, languageId);
+    if (n) {
+      names.push(n);
+    } else {
+      names.push("");
+    }
+  }
+  return names;
+}
+function extractParamName(node, languageId) {
+  switch (node.type) {
+    case "identifier":
+      return node.text;
+    case "required_parameter":
+    case "optional_parameter": {
+      const pat = node.childForFieldName("pattern");
+      if (pat) return extractParamName(pat, languageId);
+      const name2 = node.childForFieldName("name");
+      if (name2) return extractParamName(name2, languageId);
+      const id = node.namedChildren.find((c) => c.type === "identifier");
+      return id?.text ?? null;
+    }
+    case "assignment_pattern": {
+      const left = node.childForFieldName("left");
+      return left ? extractParamName(left, languageId) : null;
+    }
+    case "typed_parameter":
+    case "default_parameter":
+    case "typed_default_parameter": {
+      const name2 = node.childForFieldName("name");
+      if (name2) return extractParamName(name2, languageId);
+      const id = node.namedChildren.find((c) => c.type === "identifier");
+      return id?.text ?? null;
+    }
+    case "parameter": {
+      const id = node.namedChildren.find(
+        (c) => c.type === "identifier" || c.type === "field_identifier"
+      );
+      return id?.text ?? null;
+    }
+    default: {
+      const id = node.namedChildren.find((c) => c.type === "identifier");
+      return id?.text ?? null;
+    }
+  }
+}
+function findPostHogCallInBody(body2, allClients, family, languageId, detectNested) {
+  let found = null;
+  const visit = (node) => {
+    if (found) return;
+    const call = matchPostHogCall(
+      node,
+      allClients,
+      family,
+      languageId,
+      detectNested
+    );
+    if (call) {
+      found = call;
+      return;
+    }
+    for (const child of node.namedChildren) {
+      if (found) return;
+      visit(child);
+    }
+  };
+  visit(body2);
+  return found;
+}
+function matchPostHogCall(node, allClients, family, languageId, detectNested) {
+  if (node.type !== "call_expression" && node.type !== "call") return null;
+  const funcNode = node.childForFieldName("function");
+  if (!funcNode) return null;
+  let method = null;
+  if (funcNode.type === "member_expression" || funcNode.type === "attribute") {
+    const objNode = funcNode.childForFieldName("object") || funcNode.childForFieldName("operand");
+    const propNode = funcNode.childForFieldName("property") || funcNode.childForFieldName("attribute");
+    if (!objNode || !propNode) return null;
+    const clientName = extractClientName(objNode, detectNested);
+    if (!clientName || !allClients.has(clientName)) return null;
+    method = propNode.text;
+  } else if (funcNode.type === "selector_expression") {
+    const opNode = funcNode.childForFieldName("operand");
+    const fieldNode = funcNode.childForFieldName("field");
+    if (!opNode || !fieldNode) return null;
+    const clientName = extractClientName(opNode, detectNested);
+    if (!clientName || !allClients.has(clientName)) return null;
+    method = fieldNode.text;
+  } else {
+    return null;
+  }
+  if (!method || !family.allMethods.has(method)) return null;
+  const locator = getKeyArgLocator(method, family, languageId);
+  if (!locator) return null;
+  const argsNode = node.childForFieldName("arguments") || node.namedChildren.find(
+    (c) => c.type === "arguments" || c.type === "argument_list"
+  ) || null;
+  if (!argsNode) return null;
+  const { keyNode, kwargName } = pickKeyArg(argsNode, locator);
+  return {
+    method,
+    keyArgNode: keyNode,
+    kwargName
+  };
+}
+function pickKeyArg(argsNode, locator) {
+  const positional = [];
+  let kwargHit = null;
+  let kwargName = null;
+  for (const child of argsNode.namedChildren) {
+    if (child.type === "keyword_argument") {
+      const nameNode = child.childForFieldName("name");
+      const valueNode = child.childForFieldName("value");
+      if (nameNode && valueNode && locator.kwargName && nameNode.text === locator.kwargName) {
+        kwargHit = valueNode;
+        kwargName = nameNode.text;
+      }
+      continue;
+    }
+    positional.push(child);
+  }
+  if (kwargHit) {
+    return { keyNode: kwargHit, kwargName };
+  }
+  const positionalHit = positional[locator.positionalIndex] ?? null;
+  return { keyNode: positionalHit, kwargName: null };
+}
+function classifyKeyArg(keyArgNode, params) {
+  if (!keyArgNode) return null;
+  if (keyArgNode.type === "string" || keyArgNode.type === "interpreted_string_literal") {
+    const key = extractStringFromNode(keyArgNode);
+    return key !== null ? { kind: "fixed-key", key } : null;
+  }
+  if (keyArgNode.type === "template_string") {
+    const hasInterpolation = keyArgNode.namedChildren.some(
+      (c) => c.type === "template_substitution"
+    );
+    if (hasInterpolation) return null;
+    const key = extractStringFromNode(keyArgNode);
+    return key !== null ? { kind: "fixed-key", key } : null;
+  }
+  if (keyArgNode.type === "identifier") {
+    const idx = params.indexOf(keyArgNode.text);
+    if (idx >= 0) return { kind: "pass-through", paramIndex: idx };
+    return null;
+  }
+  return null;
+}
+function getExportStatus(nameNode, languageId) {
+  const defNode = nameNode.parent;
+  if (!defNode) return { isDefaultExport: false, isNamedExport: false };
+  if (languageId === "python") {
+    let cur2 = defNode.parent;
+    while (cur2) {
+      if (cur2.type === "module") {
+        return { isDefaultExport: false, isNamedExport: true };
+      }
+      if (cur2.type === "function_definition" || cur2.type === "class_definition") {
+        return { isDefaultExport: false, isNamedExport: false };
+      }
+      cur2 = cur2.parent;
+    }
+    return { isDefaultExport: false, isNamedExport: false };
+  }
+  let cur = defNode.parent;
+  while (cur) {
+    if (cur.type === "export_statement") {
+      const hasDefault = cur.children.some((c) => c.type === "default");
+      return { isDefaultExport: hasDefault, isNamedExport: !hasDefault };
+    }
+    if (cur.type === "program" || cur.type === "module") break;
+    cur = cur.parent;
+  }
+  return { isDefaultExport: false, isNamedExport: false };
+}
+async function findWrappers(pm, source, languageId) {
+  const ready = await pm.ensureReady(languageId);
+  if (!ready) return [];
+  const { lang, family } = ready;
+  const tree = pm.parse(source, lang);
+  if (!tree) return [];
+  const functionQuery = pm.getQuery(lang, family.queries.functions);
+  if (!functionQuery) return [];
+  const allClients = getEffectiveClients(pm.config);
+  const { clientAliases } = findAliases(pm, lang, tree, family);
+  for (const a of clientAliases) allClients.add(a);
+  const wrappers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of functionQuery.matches(tree.rootNode)) {
+    const nameNode = getCapture(match.captures, "func_name");
+    const paramsNode = getCapture(match.captures, "func_params");
+    const singleParamNode = getCapture(match.captures, "func_single_param");
+    const bodyNode = getCapture(match.captures, "func_body");
+    if (!nameNode || !bodyNode) continue;
+    const name2 = nameNode.text;
+    if (CONTROL_FLOW_KEYWORDS.has(name2)) continue;
+    if (seen.has(name2)) continue;
+    const params = extractRawParams(paramsNode, singleParamNode, languageId);
+    const call = findPostHogCallInBody(
+      bodyNode,
+      allClients,
+      family,
+      languageId,
+      pm.config.detectNestedClients
+    );
+    if (!call) continue;
+    const classification = classifyKeyArg(call.keyArgNode, params);
+    if (!classification) continue;
+    const methodKind = family.captureMethods.has(call.method) ? "capture" : "flag";
+    const posthogMethod = call.method === "Enqueue" ? "capture" : call.method;
+    const exportStatus = getExportStatus(nameNode, languageId);
+    seen.add(name2);
+    wrappers.push({
+      name: name2,
+      methodKind,
+      posthogMethod,
+      classification,
+      ...exportStatus
+    });
+  }
+  return wrappers;
+}
 var PostHogDetector = class {
   pm = new ParserManager();
   updateConfig(config) {
@@ -11588,8 +12234,8 @@ var PostHogDetector = class {
   get supportedLanguages() {
     return this.pm.supportedLanguages;
   }
-  async findPostHogCalls(source, languageId) {
-    return findPostHogCalls(this.pm, source, languageId);
+  async findPostHogCalls(source, languageId, context) {
+    return findPostHogCalls(this.pm, source, languageId, context);
   }
   async findInitCalls(source, languageId) {
     return findInitCalls(this.pm, source, languageId);
@@ -11603,6 +12249,12 @@ var PostHogDetector = class {
   async findFlagAssignments(source, languageId) {
     return findFlagAssignments(this.pm, source, languageId);
   }
+  async findWrappers(source, languageId) {
+    return findWrappers(this.pm, source, languageId);
+  }
+  async findImports(source, languageId, callerAbsPath) {
+    return findImports(this.pm, source, languageId, callerAbsPath);
+  }
   dispose() {
     this.pm.dispose();
   }
@@ -11707,18 +12359,32 @@ function commentPrefix(languageId) {
 }
 function formatFlagComment(flag) {
   const parts2 = [`Flag: "${flag.flagKey}"`];
-  if (flag.flag) {
-    parts2.push(flag.flagType);
-    if (flag.rollout !== null) {
-      parts2.push(`${flag.rollout}% rolled out`);
-    }
-    if (flag.experiment) {
-      const status = flag.experiment.end_date ? "complete" : "running";
-      parts2.push(`Experiment: "${flag.experiment.name}" (${status})`);
-    }
-    if (flag.staleness) {
-      parts2.push(`STALE (${flag.staleness})`);
-    }
+  if (!flag.flag) {
+    parts2.push("not in PostHog");
+    return parts2.join(" \u2014 ");
+  }
+  parts2.push(flag.flagType);
+  parts2.push(flag.flag.active ? "active" : "inactive");
+  if (flag.rollout !== null) {
+    parts2.push(`${flag.rollout}% rolled out`);
+  }
+  if (flag.evaluationStats) {
+    const evals = flag.evaluationStats.evaluations.toLocaleString();
+    const users = flag.evaluationStats.uniqueUsers.toLocaleString();
+    const days = flag.evaluationStats.windowDays;
+    parts2.push(`${evals} evals / ${users} users (${days}d)`);
+  } else if (flag.evaluationStatsError) {
+    parts2.push("eval stats unavailable");
+  }
+  if (flag.experiment) {
+    const status = flag.experiment.end_date ? "complete" : "running";
+    parts2.push(`Experiment: "${flag.experiment.name}" (${status})`);
+  }
+  if (flag.staleness) {
+    parts2.push(`STALE (${flag.staleness})`);
+  }
+  if (flag.url) {
+    parts2.push(flag.url);
   }
   return parts2.join(" \u2014 ");
 }
@@ -11739,21 +12405,25 @@ function formatEventComment(event) {
   return parts2.join(" \u2014 ");
 }
 function buildCommentBody(item, enrichedFlags, enrichedEvents) {
+  let body2 = null;
   if (item.type === "flag") {
     const flag = enrichedFlags.get(item.name);
-    if (flag) return formatFlagComment(flag);
-    return null;
-  }
-  if (item.type === "event") {
+    body2 = flag ? formatFlagComment(flag) : null;
+  } else if (item.type === "event") {
     const event = enrichedEvents.get(item.name);
-    if (event) return formatEventComment(event);
-    if (item.detail) return `Event: ${item.detail}`;
-    return null;
+    if (event) {
+      body2 = formatEventComment(event);
+    } else if (item.detail) {
+      body2 = `Event: ${item.detail}`;
+    }
+  } else if (item.type === "init") {
+    body2 = `Init: token "${item.name}"`;
   }
-  if (item.type === "init") {
-    return `Init: token "${item.name}"`;
+  if (!body2) return null;
+  if (item.viaWrapper) {
+    body2 = `${body2} (via ${item.viaWrapper})`;
   }
-  return null;
+  return body2;
 }
 function formatComments(source, languageId, items, enrichedFlags, enrichedEvents) {
   const prefix = commentPrefix(languageId);
@@ -11764,7 +12434,7 @@ function formatComments(source, languageId, items, enrichedFlags, enrichedEvents
     const targetLine = item.line + offset;
     const body2 = buildCommentBody(item, enrichedFlags, enrichedEvents);
     if (!body2) continue;
-    const comment = `${prefix} [PostHog] ${body2}`;
+    const comment = item.inJsx ? `{/* [PostHog] ${body2} */}` : `${prefix} [PostHog] ${body2}`;
     const indent = lines[targetLine]?.match(/^(\s*)/)?.[1] ?? "";
     lines.splice(targetLine, 0, `${indent}${comment}`);
     offset++;
@@ -11778,15 +12448,32 @@ function formatInlineComments(source, languageId, items, enrichedFlags, enriched
   for (const item of items) {
     const body2 = buildCommentBody(item, enrichedFlags, enrichedEvents);
     if (!body2) continue;
-    const arr = byLine.get(item.line) ?? [];
-    arr.push(body2);
-    byLine.set(item.line, arr);
+    const entry = byLine.get(item.line) ?? { jsxBodies: [], nonJsxBodies: [] };
+    (item.inJsx ? entry.jsxBodies : entry.nonJsxBodies).push(body2);
+    byLine.set(item.line, entry);
   }
-  for (const [lineIdx, bodies] of byLine) {
+  const leadingInserts = [];
+  for (const [lineIdx, { jsxBodies, nonJsxBodies }] of byLine) {
     if (lineIdx < 0 || lineIdx >= lines.length) continue;
-    const suffix = ` ${prefix} [PostHog] ${bodies.join(" | ")}`;
+    if (jsxBodies.length > 0 && nonJsxBodies.length > 0) {
+      const joined2 = [...nonJsxBodies, ...jsxBodies].join(" | ");
+      const indent = lines[lineIdx]?.match(/^(\s*)/)?.[1] ?? "";
+      leadingInserts.push({
+        atLine: lineIdx,
+        text: `${indent}{/* [PostHog] ${joined2} */}`
+      });
+      continue;
+    }
+    const isJsx = jsxBodies.length > 0;
+    const bodies = isJsx ? jsxBodies : nonJsxBodies;
+    const joined = bodies.join(" | ");
+    const suffix = isJsx ? ` {/* [PostHog] ${joined} */}` : ` ${prefix} [PostHog] ${joined}`;
     lines[lineIdx] = `${lines[lineIdx]}${suffix}`;
   }
+  leadingInserts.sort((a, b) => b.atLine - a.atLine);
+  for (const { atLine, text: text2 } of leadingInserts) {
+    lines.splice(atLine, 0, text2);
+  }
   return lines.join("\n");
 }
 var EnrichedResult = class {
@@ -11809,6 +12496,7 @@ var EnrichedResult = class {
       let entry = flagMap.get(check.flagKey);
       if (!entry) {
         const flag = this.context.flags?.get(check.flagKey);
+        const url = this.context.flagUrls?.get(check.flagKey) ?? null;
         entry = {
           flagKey: check.flagKey,
           occurrences: [],
@@ -11824,7 +12512,10 @@ var EnrichedResult = class {
           variants: flag ? extractVariants(flag) : [],
           experiment: experiments.find(
             (e) => e.feature_flag_key === check.flagKey
-          )
+          ),
+          url,
+          evaluationStats: this.context.flagEvaluationStats?.get(check.flagKey),
+          evaluationStatsError: this.context.flagEvaluationStatsError ?? false
         };
         flagMap.set(check.flagKey, entry);
       }
@@ -11882,6 +12573,10 @@ var EnrichedResult = class {
           enriched.flagType = flag.flagType;
           enriched.staleness = flag.staleness;
           enriched.rollout = flag.rollout;
+          enriched.active = flag.flag?.active;
+          enriched.url = flag.url;
+          enriched.evaluations = flag.evaluationStats?.evaluations;
+          enriched.evaluationUsers = flag.evaluationStats?.uniqueUsers;
           if (flag.experiment) {
             enriched.experimentName = flag.experiment.name;
             enriched.experimentStatus = flag.experiment.end_date ? "complete" : "running";
@@ -11948,8 +12643,8 @@ var PostHogApi = class {
   get signal() {
     return AbortSignal.timeout(this.config.timeoutMs ?? 1e4);
   }
-  async get(path32) {
-    const res = await fetch(`${this.baseUrl}${path32}`, {
+  async get(path42) {
+    const res = await fetch(`${this.baseUrl}${path42}`, {
       headers: {
         Authorization: `Bearer ${this.config.apiKey}`,
         "Content-Type": "application/json"
@@ -11958,13 +12653,13 @@ var PostHogApi = class {
     });
     if (!res.ok) {
       throw new Error(
-        `PostHog API error: ${res.status} ${res.statusText} on GET ${path32}`
+        `PostHog API error: ${res.status} ${res.statusText} on GET ${path42}`
       );
     }
     return res.json();
   }
-  async post(path32, body2) {
-    const res = await fetch(`${this.baseUrl}${path32}`, {
+  async post(path42, body2) {
+    const res = await fetch(`${this.baseUrl}${path42}`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.config.apiKey}`,
@@ -11975,7 +12670,7 @@ var PostHogApi = class {
     });
     if (!res.ok) {
       throw new Error(
-        `PostHog API error: ${res.status} ${res.statusText} on POST ${path32}`
+        `PostHog API error: ${res.status} ${res.statusText} on POST ${path42}`
       );
     }
     return res.json();
@@ -11993,11 +12688,11 @@ var PostHogApi = class {
     return data.results;
   }
   async getEventDefinitions(names) {
-    let path32 = "/event_definitions/?limit=500";
+    let path42 = "/event_definitions/?limit=500";
     if (names && names.length > 0) {
-      path32 += `&search=${encodeURIComponent(names.join(","))}`;
+      path42 += `&search=${encodeURIComponent(names.join(","))}`;
     }
-    const data = await this.get(path32);
+    const data = await this.get(path42);
     return data.results;
   }
   async getEventStats(eventNames, daysBack = 30) {
@@ -12033,6 +12728,35 @@ var PostHogApi = class {
     }
     return stats;
   }
+  async getFlagEvaluationStats(flagKeys, daysBack = 7) {
+    if (flagKeys.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const days = Math.max(1, Math.min(365, Math.floor(daysBack)));
+    const query2 = `
+      SELECT
+        properties.$feature_flag AS flag_key,
+        count() AS evaluations,
+        count(DISTINCT person_id) AS unique_users
+      FROM events
+      WHERE event = '$feature_flag_called'
+        AND properties.$feature_flag IN {flagKeys}
+        AND timestamp >= now() - INTERVAL ${days} DAY
+      GROUP BY flag_key
+    `;
+    const data = await this.post("/query/", {
+      query: {
+        kind: "HogQLQuery",
+        query: query2,
+        values: { flagKeys }
+      }
+    });
+    const stats = /* @__PURE__ */ new Map();
+    for (const [flagKey, evaluations, uniqueUsers] of data.results) {
+      stats.set(flagKey, { evaluations, uniqueUsers, windowDays: days });
+    }
+    return stats;
+  }
 };
 var CAPTURE_METHODS = /* @__PURE__ */ new Set(["capture", "Enqueue"]);
 var ParseResult = class {
@@ -12056,14 +12780,18 @@ var ParseResult = class {
     return this.calls.filter((c) => CAPTURE_METHODS.has(c.method)).map((c) => ({
       name: c.key,
       line: c.line,
-      dynamic: c.dynamic ?? false
+      dynamic: c.dynamic ?? false,
+      viaWrapper: c.viaWrapper,
+      inJsx: c.inJsx
     }));
   }
   get flagChecks() {
     return this.calls.filter((c) => !CAPTURE_METHODS.has(c.method)).map((c) => ({
       method: c.method,
       flagKey: c.key,
-      line: c.line
+      line: c.line,
+      viaWrapper: c.viaWrapper,
+      inJsx: c.inJsx
     }));
   }
   get flagKeys() {
@@ -12091,7 +12819,9 @@ var ParseResult = class {
         line: call.line,
         name: call.key,
         method: call.method,
-        detail: call.dynamic ? "dynamic event name" : void 0
+        detail: call.dynamic ? "dynamic event name" : void 0,
+        viaWrapper: call.viaWrapper,
+        inJsx: call.inJsx
       });
     }
     return items.sort((a, b) => a.line - b.line);
@@ -12104,14 +12834,22 @@ var ParseResult = class {
       flagKeys.length > 0 ? api.getFeatureFlags() : Promise.resolve([]),
       flagKeys.length > 0 ? api.getExperiments() : Promise.resolve([]),
       eventNames.length > 0 ? api.getEventDefinitions(eventNames) : Promise.resolve([]),
-      eventNames.length > 0 ? api.getEventStats(eventNames) : Promise.resolve(/* @__PURE__ */ new Map())
+      eventNames.length > 0 ? api.getEventStats(eventNames) : Promise.resolve(/* @__PURE__ */ new Map()),
+      flagKeys.length > 0 ? api.getFlagEvaluationStats(flagKeys, 7) : Promise.resolve(/* @__PURE__ */ new Map())
     ]);
-    const [flagsResult, experimentsResult, eventDefsResult, eventStatsResult] = settled;
+    const [
+      flagsResult,
+      experimentsResult,
+      eventDefsResult,
+      eventStatsResult,
+      flagEvalStatsResult
+    ] = settled;
     const labels = [
       "getFeatureFlags",
       "getExperiments",
       "getEventDefinitions",
-      "getEventStats"
+      "getEventStats",
+      "getFlagEvaluationStats"
     ];
     settled.forEach((r, i2) => {
       if (r.status === "rejected") {
@@ -12122,6 +12860,8 @@ var ParseResult = class {
     const allExperiments = experimentsResult.status === "fulfilled" ? experimentsResult.value : [];
     const allEventDefs = eventDefsResult.status === "fulfilled" ? eventDefsResult.value : [];
     const eventStats = eventStatsResult.status === "fulfilled" ? eventStatsResult.value : /* @__PURE__ */ new Map();
+    const flagEvaluationStats = flagEvalStatsResult.status === "fulfilled" ? flagEvalStatsResult.value : /* @__PURE__ */ new Map();
+    const flagEvaluationStatsError = flagEvalStatsResult.status === "rejected";
     const flagKeySet = new Set(flagKeys);
     const flags2 = new Map(
       allFlags.filter((f) => flagKeySet.has(f.key)).map((f) => [f.key, f])
@@ -12132,18 +12872,34 @@ var ParseResult = class {
     const eventDefinitions = new Map(
       allEventDefs.filter((d) => eventNames.includes(d.name)).map((d) => [d.name, d])
     );
+    const host = config.host.replace(/\/$/, "");
+    const flagUrls = /* @__PURE__ */ new Map();
+    for (const [key, flag] of flags2) {
+      flagUrls.set(
+        key,
+        `${host}/project/${config.projectId}/feature_flags/${flag.id}`
+      );
+    }
     return new EnrichedResult(this, {
       flags: flags2,
       experiments,
       eventDefinitions,
-      eventStats
+      eventStats,
+      flagEvaluationStats,
+      flagEvaluationStatsError,
+      flagUrls
     });
   }
 };
+var MAX_WRAPPER_SOURCE_BYTES = 1e6;
+var WRAPPER_CACHE_MAX = 1024;
+var POSTHOG_LITERAL_REGEX = /posthog/i;
 var PostHogEnricher = class {
   detector = new PostHogDetector();
+  wrapperCache = /* @__PURE__ */ new Map();
   updateConfig(config) {
     this.detector.updateConfig(config);
+    this.wrapperCache.clear();
   }
   isSupported(langId) {
     return this.detector.isSupported(langId);
@@ -12151,9 +12907,9 @@ var PostHogEnricher = class {
   get supportedLanguages() {
     return this.detector.supportedLanguages;
   }
-  async parse(source, languageId) {
+  async parse(source, languageId, context) {
     const results = await Promise.allSettled([
-      this.detector.findPostHogCalls(source, languageId),
+      this.detector.findPostHogCalls(source, languageId, context),
       this.detector.findInitCalls(source, languageId),
       this.detector.findFlagAssignments(source, languageId),
       this.detector.findVariantBranches(source, languageId),
@@ -12184,7 +12940,7 @@ var PostHogEnricher = class {
     );
   }
   async parseFile(filePath) {
-    const ext = path22.extname(filePath).toLowerCase();
+    const ext = path32.extname(filePath).toLowerCase();
     const languageId = EXT_TO_LANG_ID[ext];
     if (!languageId) {
       throw new Error(`Unsupported file extension: ${ext}`);
@@ -12192,8 +12948,70 @@ var PostHogEnricher = class {
     const source = await fs4.readFile(filePath, "utf-8");
     return this.parse(source, languageId);
   }
+  /**
+   * Parse a file for wrapper definitions (functions that directly call PostHog SDK methods).
+   * Results are cached per absolute path + mtime so subsequent calls within the same session
+   * are cheap. Returns [] for unsupported extensions, unreadable files, or files larger than
+   * `MAX_WRAPPER_SOURCE_BYTES`.
+   */
+  async getWrappersForFile(absPath) {
+    const ext = path32.extname(absPath).toLowerCase();
+    const languageId = EXT_TO_LANG_ID[ext];
+    if (!languageId || !this.isSupported(languageId)) {
+      return this.setWrapperCache(absPath, 0, []);
+    }
+    let mtimeMs = 0;
+    try {
+      const stat2 = await fs4.stat(absPath);
+      mtimeMs = stat2.mtimeMs;
+      if (stat2.size > MAX_WRAPPER_SOURCE_BYTES) {
+        return this.setWrapperCache(absPath, mtimeMs, []);
+      }
+    } catch {
+      return this.setWrapperCache(absPath, 0, []);
+    }
+    const cached = this.wrapperCache.get(absPath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+      this.touchCache(absPath);
+      return cached.wrappers;
+    }
+    let source;
+    try {
+      source = await fs4.readFile(absPath, "utf-8");
+    } catch {
+      return this.setWrapperCache(absPath, mtimeMs, []);
+    }
+    if (!POSTHOG_LITERAL_REGEX.test(source)) {
+      return this.setWrapperCache(absPath, mtimeMs, []);
+    }
+    const wrappers = await this.detector.findWrappers(source, languageId);
+    return this.setWrapperCache(absPath, mtimeMs, wrappers);
+  }
+  async findImportsInSource(source, languageId, callerAbsPath) {
+    return this.detector.findImports(source, languageId, callerAbsPath);
+  }
+  clearWrapperCache() {
+    this.wrapperCache.clear();
+  }
   dispose() {
     this.detector.dispose();
+    this.wrapperCache.clear();
+  }
+  setWrapperCache(absPath, mtimeMs, wrappers) {
+    if (this.wrapperCache.size >= WRAPPER_CACHE_MAX) {
+      const oldest = this.wrapperCache.keys().next().value;
+      if (oldest !== void 0) {
+        this.wrapperCache.delete(oldest);
+      }
+    }
+    this.wrapperCache.set(absPath, { mtimeMs, wrappers });
+    return wrappers;
+  }
+  touchCache(absPath) {
+    const entry = this.wrapperCache.get(absPath);
+    if (!entry) return;
+    this.wrapperCache.delete(absPath);
+    this.wrapperCache.set(absPath, entry);
   }
 };
 
@@ -12207,14 +13025,25 @@ function createEnrichment(apiConfig, logger) {
   };
 }
 var MAX_ENRICHMENT_BYTES = 1e6;
+var MAX_RELATIVE_IMPORTS = 64;
+var RELATIVE_IMPORT_REGEX = /(?:^|\n)\s*(?:import\b[^\n]*['"]\.{1,2}\/|from\s+\.)/;
+var POSTHOG_LITERAL_REGEX2 = /posthog/i;
 async function enrichFileForAgent(deps, filePath, content) {
   if (!content || content.length > MAX_ENRICHMENT_BYTES) return null;
-  if (!/posthog/i.test(content)) return null;
   const ext = path4.extname(filePath).toLowerCase();
   const langId = EXT_TO_LANG_ID[ext];
   if (!langId || !deps.enricher.isSupported(langId)) return null;
+  const hasPostHogLiteral = POSTHOG_LITERAL_REGEX2.test(content);
+  const hasRelativeImport = RELATIVE_IMPORT_REGEX.test(content);
+  let parseContext;
+  if (hasRelativeImport) {
+    const absPath = path4.resolve(filePath);
+    const ctx = await buildWrapperContext(deps, content, langId, absPath);
+    if (ctx) parseContext = ctx;
+  }
+  if (!hasPostHogLiteral && !parseContext) return null;
   try {
-    const parsed = await deps.enricher.parse(content, langId);
+    const parsed = await deps.enricher.parse(content, langId, parseContext);
     if (parsed.calls.length === 0 && parsed.initCalls.length === 0) {
       return null;
     }
@@ -12236,7 +13065,8 @@ async function enrichFileForAgent(deps, filePath, content) {
     }
     deps.logger?.debug("File enriched", {
       filePath,
-      calls: parsed.calls.length
+      calls: parsed.calls.length,
+      viaWrappers: parsed.calls.filter((c) => c.viaWrapper).length
     });
     return annotated;
   } catch (err2) {
@@ -12245,11 +13075,62 @@ async function enrichFileForAgent(deps, filePath, content) {
     return null;
   }
 }
+async function buildWrapperContext(deps, content, langId, absPath) {
+  let edges;
+  try {
+    edges = await deps.enricher.findImportsInSource(content, langId, absPath);
+  } catch (err2) {
+    deps.logger?.debug("Import resolution failed", {
+      absPath,
+      err: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return null;
+  }
+  if (!edges.length) return null;
+  const bounded = edges.slice(0, MAX_RELATIVE_IMPORTS);
+  const wrappersByLocalName = /* @__PURE__ */ new Map();
+  const namespaceWrappers = /* @__PURE__ */ new Map();
+  const resolutions = await Promise.all(
+    bounded.map(async (edge) => {
+      if (!edge.resolvedAbsPath) return null;
+      const wrappers = await deps.enricher.getWrappersForFile(
+        edge.resolvedAbsPath
+      );
+      if (!wrappers.length) return null;
+      return { edge, wrappers };
+    })
+  );
+  for (const entry of resolutions) {
+    if (!entry) continue;
+    const { edge, wrappers } = entry;
+    if (edge.isNamespace) {
+      const nsMap = /* @__PURE__ */ new Map();
+      for (const w of wrappers) {
+        if (w.isNamedExport || w.isDefaultExport) {
+          nsMap.set(w.name, w);
+        }
+      }
+      if (nsMap.size) namespaceWrappers.set(edge.localName, nsMap);
+      continue;
+    }
+    if (edge.isDefault) {
+      const target2 = wrappers.find((w) => w.isDefaultExport);
+      if (target2) wrappersByLocalName.set(edge.localName, target2);
+      continue;
+    }
+    const target = wrappers.find(
+      (w) => w.name === edge.importedName && w.isNamedExport
+    );
+    if (target) wrappersByLocalName.set(edge.localName, target);
+  }
+  if (!wrappersByLocalName.size && !namespaceWrappers.size) return null;
+  return { wrappersByLocalName, namespaceWrappers };
+}
 
 // src/utils/common.ts
 async function withTimeout(operation, timeoutMs) {
   const timeoutPromise = new Promise(
-    (resolve4) => setTimeout(() => resolve4({ result: "timeout" }), timeoutMs)
+    (resolve6) => setTimeout(() => resolve6({ result: "timeout" }), timeoutMs)
   );
   const operationPromise = operation.then((value) => ({
     result: "success",
@@ -12735,7 +13616,7 @@ function buildToolKey(serverName, toolName) {
   return `mcp__${serverName}__${toolName}`;
 }
 function delay2(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function fetchMcpToolMetadata(q, logger = new Logger({ debug: false, prefix: "[McpToolMetadata]" })) {
   let retries = 0;
@@ -15056,8 +15937,8 @@ var AsyncMutex = class {
       this.locked = true;
       return;
     }
-    return new Promise((resolve4) => {
-      this.queue.push(resolve4);
+    return new Promise((resolve6) => {
+      this.queue.push(resolve6);
     });
   }
   release() {
@@ -15592,8 +16473,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (this.session.promptRunning) {
       this.session.input.push(userMessage);
       const order = this.session.nextPendingOrder++;
-      const cancelled = await new Promise((resolve4) => {
-        this.session.pendingMessages.set(promptUuid, { resolve: resolve4, order });
+      const cancelled = await new Promise((resolve6) => {
+        this.session.pendingMessages.set(promptUuid, { resolve: resolve6, order });
       });
       if (cancelled) {
         return { stopReason: "cancelled" };
@@ -16464,7 +17345,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
    */
   deferBackgroundFetches(q) {
     Promise.all([
-      new Promise((resolve4) => setTimeout(resolve4, 10)).then(
+      new Promise((resolve6) => setTimeout(resolve6, 10)).then(
         () => this.sendAvailableCommandsUpdate()
       ),
       fetchMcpToolMetadata(q, this.logger).then(() => {
@@ -16746,7 +17627,7 @@ function parseCodexToml(content, cwd) {
 // src/adapters/codex/spawn.ts
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
-import { delimiter, dirname as dirname4 } from "path";
+import { delimiter, dirname as dirname5 } from "path";
 function buildConfigArgs(options) {
   const args2 = [];
   args2.push("-c", `features.remote_models=false`);
@@ -16797,7 +17678,7 @@ function spawnCodexProcess(options) {
   }
   const { command, args: args2 } = findCodexBinary(options);
   if (options.binaryPath && existsSync4(options.binaryPath)) {
-    const binDir = dirname4(options.binaryPath);
+    const binDir = dirname5(options.binaryPath);
     env.PATH = `${binDir}${delimiter}${env.PATH ?? ""}`;
   }
   logger.info("Spawning codex-acp process", {
@@ -17816,7 +18697,7 @@ var Saga = class {
 
 // src/sagas/apply-snapshot-saga.ts
 import { mkdir as mkdir4, rm as rm3, writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // ../git/dist/sagas/tree.js
 import { existsSync as existsSync5 } from "fs";
@@ -18104,7 +18985,7 @@ var ApplySnapshotSaga = class extends Saga {
   archivePath = null;
   async execute(input) {
     const { snapshot, repositoryPath, apiClient, taskId, runId } = input;
-    const tmpDir = join9(repositoryPath, ".posthog", "tmp");
+    const tmpDir = join10(repositoryPath, ".posthog", "tmp");
     if (!snapshot.archiveUrl) {
       throw new Error("Cannot apply snapshot: no archive URL");
     }
@@ -18115,7 +18996,7 @@ var ApplySnapshotSaga = class extends Saga {
       rollback: async () => {
       }
     });
-    const archivePath = join9(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    const archivePath = join10(tmpDir, `${snapshot.treeHash}.tar.gz`);
     this.archivePath = archivePath;
     await this.step({
       name: "download_archive",
@@ -18164,7 +19045,7 @@ var ApplySnapshotSaga = class extends Saga {
 // src/sagas/capture-tree-saga.ts
 import { existsSync as existsSync6 } from "fs";
 import { readFile as readFile4, rm as rm4 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var CaptureTreeSaga2 = class extends Saga {
   sagaName = "CaptureTreeSaga";
   async execute(input) {
@@ -18176,14 +19057,14 @@ var CaptureTreeSaga2 = class extends Saga {
       taskId,
       runId
     } = input;
-    const tmpDir = join10(repositoryPath, ".posthog", "tmp");
-    if (existsSync6(join10(repositoryPath, ".gitmodules"))) {
+    const tmpDir = join11(repositoryPath, ".posthog", "tmp");
+    if (existsSync6(join11(repositoryPath, ".gitmodules"))) {
       this.log.warn(
         "Repository has submodules - snapshot may not capture submodule state"
       );
     }
     const shouldArchive = !!apiClient;
-    const archivePath = shouldArchive ? join10(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
+    const archivePath = shouldArchive ? join11(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
     const gitCaptureSaga = new CaptureTreeSaga(this.log);
     const captureResult = await gitCaptureSaga.run({
       baseDir: repositoryPath,
@@ -19425,7 +20306,7 @@ var AgentServer = class _AgentServer {
     return app;
   }
   async start() {
-    await new Promise((resolve4) => {
+    await new Promise((resolve6) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -19435,7 +20316,7 @@ var AgentServer = class _AgentServer {
           this.logger.debug(
             `HTTP server listening on port ${this.config.port}`
           );
-          resolve4();
+          resolve6();
         }
       );
     });
@@ -20174,7 +21055,7 @@ ${toolSummary}`);
       throw new Error(`Failed to download artifact ${artifact.name}`);
     }
     const safeName = this.getSafeArtifactName(artifact.name);
-    const artifactDir = join11(
+    const artifactDir = join12(
       this.config.repositoryPath ?? "/tmp/workspace",
       ".posthog",
       "attachments",
@@ -20182,7 +21063,7 @@ ${toolSummary}`);
       artifact.id ?? safeName
     );
     await mkdir5(artifactDir, { recursive: true });
-    const artifactPath = join11(artifactDir, safeName);
+    const artifactPath = join12(artifactDir, safeName);
     await writeFile5(artifactPath, Buffer.from(data));
     return resourceLink(pathToFileURL(artifactPath).toString(), artifact.name, {
       ...artifact.content_type ? { mimeType: artifact.content_type } : {},
@@ -20794,8 +21675,8 @@ ${attributionInstructions}
       options: params.options,
       toolCall: params.toolCall
     });
-    return new Promise((resolve4) => {
-      this.pendingPermissions.set(requestId, { resolve: resolve4 });
+    return new Promise((resolve6) => {
+      this.pendingPermissions.set(requestId, { resolve: resolve6 });
     });
   }
   resolvePermission(requestId, optionId, customInput, answers) {