@easyfunnel/mcp 0.1.1 → 0.1.2

package/dist/index.js

@@ -52,12 +52,46 @@ var ApiClient = class {
       `/projects/${projectId}/funnels/${funnelId}?${params.toString()}`
     );
   }
+  async listFunnels(projectId) {
+    return this.request(`/projects/${projectId}/funnels`);
+  }
+  async deleteFunnel(projectId, funnelId) {
+    return this.request(`/projects/${projectId}/funnels/${funnelId}`, {
+      method: "DELETE"
+    });
+  }
+  async updateFunnel(projectId, funnelId, updates) {
+    return this.request(`/projects/${projectId}/funnels/${funnelId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+  }
+  async sendTestEvent(projectApiKey, sessionId) {
+    const url = `${this.baseUrl}/api/collect`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        api_key: projectApiKey,
+        events: [
+          {
+            session_id: sessionId,
+            event_name: "__ef_test",
+            properties: { source: "mcp_validation" },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ]
+      })
+    });
+    return { status: res.status, body: await res.text() };
+  }
   async queryEvents(projectId, params) {
     const searchParams = new URLSearchParams();
     searchParams.set("query_type", params.query_type);
     if (params.event_name) searchParams.set("event_name", params.event_name);
     if (params.time_range) searchParams.set("time_range", params.time_range);
     if (params.group_by) searchParams.set("group_by", params.group_by);
+    if (params.property_name) searchParams.set("property_name", params.property_name);
     if (params.limit) searchParams.set("limit", params.limit.toString());
     return this.request(
       `/projects/${projectId}/events?${searchParams.toString()}`
@@ -120,7 +154,7 @@ var import_path = require("path");
 var import_child_process = require("child_process");
 var setupSdkDefinition = {
   name: "setup_sdk",
-  description: "Install the easyfunnel SDK and add the provider to a Next.js/React project",
+  description: "Install the EasyFunnel SDK, write the env var, and wrap the app with the provider. Supports Next.js, Vite, CRA, SvelteKit, and plain HTML.",
   inputSchema: {
     type: "object",
     properties: {
@@ -134,13 +168,39 @@ var setupSdkDefinition = {
       },
       framework: {
         type: "string",
-        enum: ["nextjs", "react", "html"],
+        enum: ["nextjs", "vite", "cra", "sveltekit", "html"],
         description: "The framework used in the project"
       }
     },
     required: ["project_api_key", "project_root", "framework"]
   }
 };
+var frameworkConfigs = {
+  nextjs: {
+    envFile: ".env.local",
+    envVarName: "NEXT_PUBLIC_EASYFUNNEL_KEY",
+    envAccessor: "process.env.NEXT_PUBLIC_EASYFUNNEL_KEY!",
+    layoutPaths: ["app/layout.tsx", "app/layout.jsx", "src/app/layout.tsx", "src/app/layout.jsx"]
+  },
+  vite: {
+    envFile: ".env",
+    envVarName: "VITE_EASYFUNNEL_KEY",
+    envAccessor: "import.meta.env.VITE_EASYFUNNEL_KEY",
+    layoutPaths: ["src/App.tsx", "src/App.jsx", "src/main.tsx", "src/main.jsx"]
+  },
+  cra: {
+    envFile: ".env",
+    envVarName: "REACT_APP_EASYFUNNEL_KEY",
+    envAccessor: "process.env.REACT_APP_EASYFUNNEL_KEY!",
+    layoutPaths: ["src/App.tsx", "src/App.jsx", "src/index.tsx", "src/index.jsx"]
+  },
+  sveltekit: {
+    envFile: ".env",
+    envVarName: "PUBLIC_EASYFUNNEL_KEY",
+    envAccessor: "import.meta.env.PUBLIC_EASYFUNNEL_KEY",
+    layoutPaths: ["src/routes/+layout.svelte"]
+  }
+};
 function detectPackageManager(projectRoot) {
   if ((0, import_fs.existsSync)((0, import_path.join)(projectRoot, "bun.lockb"))) return "bun";
   if ((0, import_fs.existsSync)((0, import_path.join)(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
@@ -149,101 +209,142 @@ function detectPackageManager(projectRoot) {
 }
 async function setupSdk(args) {
   const { project_api_key, project_root, framework } = args;
-  const filesModified = [];
+  if (!project_api_key?.startsWith("ef_")) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Invalid API key format. Project keys start with "ef_". Got: "${project_api_key || "(empty)"}"
+
+Account keys ("efa_") are for the MCP server, not the SDK. Use list_projects to find your project API key.`
+        }
+      ]
+    };
+  }
   if (framework === "html") {
     return {
       content: [
         {
           type: "text",
-          text: `For HTML projects, add this script tag to your <head>:
+          text: `SDK SETUP COMPLETE
+
+Add this script tag to your <head>:
+
+  <script defer data-api-key="${project_api_key}" src="https://easyfunnel.co/sdk.js"></script>
 
-<script defer data-api-key="${project_api_key}" src="https://easyfunnel.co/sdk.js"></script>
+This will automatically track page views and clicks on elements with data-ef-track attributes.
 
-This will automatically track page views and clicks on elements with data-ef-track attributes.`
+Next: After adding the script, I'll verify everything works with a test event.`
         }
       ]
     };
   }
+  const config = frameworkConfigs[framework];
+  const steps = [];
+  const filesModified = [];
   const pm = detectPackageManager(project_root);
   const installCmd = pm === "npm" ? "npm install @easyfunnel/sdk @easyfunnel/react" : `${pm} add @easyfunnel/sdk @easyfunnel/react`;
   try {
     (0, import_child_process.execSync)(installCmd, { cwd: project_root, stdio: "pipe" });
-  } catch (e) {
+    steps.push(`[done] Installed @easyfunnel/sdk and @easyfunnel/react via ${pm}`);
+    filesModified.push({ file: "package.json", action: "Added SDK dependencies" });
+  } catch {
+    steps.push(`[skip] Package install failed (may already be installed)`);
   }
-  filesModified.push("package.json");
-  const envPath = (0, import_path.join)(project_root, ".env.local");
-  const envLine = `NEXT_PUBLIC_EASYFUNNEL_KEY=${project_api_key}`;
+  const envPath = (0, import_path.join)(project_root, config.envFile);
+  const envLine = `${config.envVarName}=${project_api_key}`;
+  let envWritten = false;
   if ((0, import_fs.existsSync)(envPath)) {
     const content = (0, import_fs.readFileSync)(envPath, "utf-8");
-    if (!content.includes("NEXT_PUBLIC_EASYFUNNEL_KEY")) {
-      (0, import_fs.writeFileSync)(envPath, content + "\n" + envLine + "\n");
-      filesModified.push(".env.local");
+    if (!content.includes(config.envVarName)) {
+      (0, import_fs.writeFileSync)(envPath, content.trimEnd() + "\n" + envLine + "\n");
+      envWritten = true;
+    } else {
+      steps.push(`[skip] ${config.envVarName} already exists in ${config.envFile}`);
     }
   } else {
     (0, import_fs.writeFileSync)(envPath, envLine + "\n");
-    filesModified.push(".env.local");
-  }
-  if (framework === "nextjs") {
-    const layoutPaths = [
-      (0, import_path.join)(project_root, "app", "layout.tsx"),
-      (0, import_path.join)(project_root, "app", "layout.jsx"),
-      (0, import_path.join)(project_root, "src", "app", "layout.tsx"),
-      (0, import_path.join)(project_root, "src", "app", "layout.jsx")
-    ];
-    for (const layoutPath of layoutPaths) {
-      if ((0, import_fs.existsSync)(layoutPath)) {
-        let content = (0, import_fs.readFileSync)(layoutPath, "utf-8");
-        if (!content.includes("EasyFunnelProvider")) {
-          const importLine = `import { EasyFunnelProvider } from '@easyfunnel/react'
-`;
-          content = importLine + content;
-          content = content.replace(
-            /(\{children\})/,
-            `<EasyFunnelProvider apiKey={process.env.NEXT_PUBLIC_EASYFUNNEL_KEY!}>
+    envWritten = true;
+  }
+  if (envWritten) {
+    const verifyContent = (0, import_fs.readFileSync)(envPath, "utf-8");
+    if (verifyContent.includes(project_api_key)) {
+      steps.push(`[done] Added ${config.envVarName}=${project_api_key.slice(0, 8)}... to ${config.envFile}`);
+      filesModified.push({ file: config.envFile, action: "Added API key" });
+    } else {
+      steps.push(`[FAIL] Wrote to ${config.envFile} but verification failed`);
+    }
+  }
+  let providerWrapped = false;
+  for (const relPath of config.layoutPaths) {
+    const fullPath = (0, import_path.join)(project_root, relPath);
+    if (!(0, import_fs.existsSync)(fullPath)) continue;
+    let content = (0, import_fs.readFileSync)(fullPath, "utf-8");
+    if (content.includes("EasyFunnelProvider")) {
+      steps.push(`[skip] EasyFunnelProvider already present in ${relPath}`);
+      providerWrapped = true;
+      break;
+    }
+    if (framework === "sveltekit") {
+      const importLine2 = `<script>
+  import { EasyFunnelProvider } from '@easyfunnel/react'
+</script>
+
+`;
+      content = importLine2 + content;
+      (0, import_fs.writeFileSync)(fullPath, content);
+      steps.push(`[done] Added EasyFunnelProvider import to ${relPath}`);
+      filesModified.push({ file: relPath, action: "Added provider import" });
+      providerWrapped = true;
+      break;
+    }
+    const importLine = `import { EasyFunnelProvider } from '@easyfunnel/react'
+`;
+    content = importLine + content;
+    if (content.includes("{children}")) {
+      content = content.replace(
+        /(\{children\})/,
+        `<EasyFunnelProvider apiKey={${config.envAccessor}}>
           $1
         </EasyFunnelProvider>`
-          );
-          (0, import_fs.writeFileSync)(layoutPath, content);
-          filesModified.push(layoutPath.replace(project_root + "/", ""));
-        }
-        break;
-      }
-    }
-  } else if (framework === "react") {
-    const appPaths = [
-      (0, import_path.join)(project_root, "src", "App.tsx"),
-      (0, import_path.join)(project_root, "src", "App.jsx"),
-      (0, import_path.join)(project_root, "App.tsx"),
-      (0, import_path.join)(project_root, "App.jsx")
-    ];
-    for (const appPath of appPaths) {
-      if ((0, import_fs.existsSync)(appPath)) {
-        let content = (0, import_fs.readFileSync)(appPath, "utf-8");
-        if (!content.includes("EasyFunnelProvider")) {
-          const importLine = `import { EasyFunnelProvider } from '@easyfunnel/react'
-`;
-          content = importLine + content;
-          (0, import_fs.writeFileSync)(appPath, content);
-          filesModified.push(appPath.replace(project_root + "/", ""));
-        }
-        break;
-      }
+      );
+      steps.push(`[done] Wrapped {children} with <EasyFunnelProvider> in ${relPath}`);
+    } else {
+      steps.push(`[done] Added EasyFunnelProvider import to ${relPath} (manual wrapping may be needed)`);
     }
+    (0, import_fs.writeFileSync)(fullPath, content);
+    filesModified.push({ file: relPath, action: "Added provider wrapper" });
+    providerWrapped = true;
+    break;
   }
-  return {
-    content: [
-      {
-        type: "text",
-        text: `SDK setup complete!
+  if (!providerWrapped) {
+    steps.push(`[skip] Could not find layout file to add provider. Searched: ${config.layoutPaths.join(", ")}`);
+  }
+  let output = `SDK SETUP COMPLETE
 
+`;
+  output += `What I did:
+`;
+  for (const step of steps) {
+    output += `  ${step}
+`;
+  }
+  if (filesModified.length > 0) {
+    output += `
 Files modified:
-${filesModified.map((f) => `  - ${f}`).join("\n")}
-
-The EasyFunnel provider is now wrapping your app. Page views and click tracking are automatic.
-
-Next: I can scan your codebase for interactive elements to add tracking to.`
-      }
-    ]
+`;
+    for (const f of filesModified) {
+      output += `  ${f.file.padEnd(20)} ${f.action}
+`;
+    }
+  }
+  output += `
+IMPORTANT: Restart your dev server for the env var to take effect.
+`;
+  output += `
+Next: After restarting, I'll verify everything works with a test event.`;
+  return {
+    content: [{ type: "text", text: output }]
   };
 }
 
@@ -486,6 +587,9 @@ Apply this change to ${file} at line ${line}.`
 }
 
 // src/tools/create-funnel.ts
+function humanizeEventName(name) {
+  return name.split(/[_-]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
 var createFunnelDefinition = {
   name: "create_funnel",
   description: "Create a conversion funnel from a sequence of events",
@@ -500,9 +604,9 @@ var createFunnelDefinition = {
           type: "object",
           properties: {
             event_name: { type: "string" },
-            label: { type: "string" }
+            label: { type: "string", description: "Display label (auto-generated from event name if omitted)" }
           },
-          required: ["event_name", "label"]
+          required: ["event_name"]
         },
         description: "Ordered funnel steps"
       }
@@ -511,12 +615,16 @@ var createFunnelDefinition = {
   }
 };
 async function createFunnel(client2, args) {
+  const stepsWithLabels = args.steps.map((s) => ({
+    event_name: s.event_name,
+    label: s.label || humanizeEventName(s.event_name)
+  }));
   const funnel = await client2.createFunnel(
     args.project_id,
     args.name,
-    args.steps
+    stepsWithLabels
   );
-  const stepsDisplay = args.steps.map((s, i) => `  ${i + 1}. ${s.label} (${s.event_name})`).join("\n");
+  const stepsDisplay = stepsWithLabels.map((s, i) => `  ${i + 1}. ${s.label} (${s.event_name})`).join("\n");
   return {
     content: [
       {
@@ -591,14 +699,14 @@ Median time to convert: ${data.median_time_to_convert}`;
 // src/tools/query-events.ts
 var queryEventsDefinition = {
   name: "query_events",
-  description: "Query raw event data for a project \u2014 counts, recent events, or filtered lists",
+  description: "Query event data for a project \u2014 counts, recent events, breakdowns, section engagement, or traffic sources",
   inputSchema: {
     type: "object",
     properties: {
       project_id: { type: "string", description: "Project ID" },
       query_type: {
         type: "string",
-        enum: ["count", "recent", "breakdown"],
+        enum: ["count", "recent", "breakdown", "section_engagement", "traffic_sources"],
         description: "Type of query"
       },
       event_name: {
@@ -612,8 +720,12 @@ var queryEventsDefinition = {
       },
       group_by: {
         type: "string",
-        enum: ["event_name", "url", "browser", "os"],
-        description: "Group by field (for breakdown query)"
+        enum: ["event_name", "url", "browser", "os", "property"],
+        description: 'Group by field (for breakdown query). Use "property" with property_name for JSONB grouping.'
+      },
+      property_name: {
+        type: "string",
+        description: 'Property name to group by when group_by is "property" (e.g. "source", "medium", "section")'
       },
       limit: {
         type: "number",
@@ -645,6 +757,25 @@ async function queryEvents(client2, args) {
       output += "\n";
     }
     if (!data.events?.length) output += "  No events found.\n";
+  } else if (args.query_type === "section_engagement") {
+    output = `Section engagement (${args.time_range || "7d"}):
+
+`;
+    for (const section of data.sections || []) {
+      const dwellSec = (section.avg_dwell_ms / 1e3).toFixed(1);
+      output += `  ${section.section}: ${section.views} views, ${section.unique_sessions} sessions, ${dwellSec}s avg dwell
+`;
+    }
+    if (!data.sections?.length) output += "  No section data found.\n";
+  } else if (args.query_type === "traffic_sources") {
+    output = `Traffic sources (${args.time_range || "7d"}):
+
+`;
+    for (const source of data.sources || []) {
+      output += `  ${source.source} (${source.medium}): ${source.sessions} sessions, ${source.events} events
+`;
+    }
+    if (!data.sources?.length) output += "  No traffic data found.\n";
   } else {
     output = `Event breakdown (${args.time_range || "7d"}):
 
@@ -662,6 +793,1135 @@ async function queryEvents(client2, args) {
   };
 }
 
+// src/tools/delete-funnel.ts
+var deleteFunnelDefinition = {
+  name: "delete_funnel",
+  description: "Delete a funnel from the server and get cleanup instructions for removing related tracking code from the codebase",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: { type: "string", description: "Project ID" },
+      funnel_id: { type: "string", description: "Funnel ID to delete" },
+      funnel_slug: {
+        type: "string",
+        description: 'Funnel slug from easyfunnel.config.ts (e.g. "trial-to-paid") for cleanup instructions'
+      }
+    },
+    required: ["project_id", "funnel_id"]
+  }
+};
+async function deleteFunnel(client2, args) {
+  await client2.deleteFunnel(args.project_id, args.funnel_id);
+  let output = `Funnel deleted from server.
+`;
+  if (args.funnel_slug) {
+    output += `
+To clean up your code:
+`;
+    output += `1. Remove the '${args.funnel_slug}' entry from easyfunnel.config.ts (both rules and funnels sections)
+`;
+    output += `2. Remove lines with // @ef:${args.funnel_slug} from your codebase:
+`;
+    output += `   grep -rn "@ef:${args.funnel_slug}" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx"
+`;
+    output += `3. Remove any tracking rules whose events only belong to this funnel
+`;
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/update-funnel.ts
+var updateFunnelDefinition = {
+  name: "update_funnel",
+  description: "Update a funnel name and/or steps",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: { type: "string", description: "Project ID" },
+      funnel_id: { type: "string", description: "Funnel ID to update" },
+      name: { type: "string", description: "New funnel name (optional)" },
+      steps: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            event_name: { type: "string" },
+            label: { type: "string" }
+          },
+          required: ["event_name", "label"]
+        },
+        description: "New ordered funnel steps (optional)"
+      }
+    },
+    required: ["project_id", "funnel_id"]
+  }
+};
+async function updateFunnel(client2, args) {
+  const updates = {};
+  if (args.name) updates.name = args.name;
+  if (args.steps) updates.steps = args.steps;
+  const funnel = await client2.updateFunnel(args.project_id, args.funnel_id, updates);
+  const stepsDisplay = funnel.steps.sort((a, b) => a.order - b.order).map((s, i) => `  ${i + 1}. ${s.label} (${s.event_name})`).join("\n");
+  let output = `Funnel "${funnel.name}" updated!
+
+ID: ${funnel.id}
+Steps:
+${stepsDisplay}
+`;
+  if (args.steps) {
+    output += `
+Remember to update easyfunnel.config.ts to match the new steps.`;
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/scan-codebase.ts
+var import_fs5 = require("fs");
+
+// src/lib/scanners.ts
+var import_fs4 = require("fs");
+var import_path3 = require("path");
+function walkDir2(dir, extensions, results = [], maxFiles = 500) {
+  if (results.length >= maxFiles) return results;
+  try {
+    const entries = (0, import_fs4.readdirSync)(dir);
+    for (const entry of entries) {
+      if (results.length >= maxFiles) break;
+      if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === ".next" || entry === "build" || entry === "coverage" || entry === "__pycache__") {
+        continue;
+      }
+      const fullPath = (0, import_path3.join)(dir, entry);
+      try {
+        const stat = (0, import_fs4.statSync)(fullPath);
+        if (stat.isDirectory()) {
+          walkDir2(fullPath, extensions, results, maxFiles);
+        } else if (extensions.some((ext) => entry.endsWith(ext))) {
+          results.push(fullPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function readFileSafe(path) {
+  try {
+    return (0, import_fs4.readFileSync)(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function detectFramework(dir) {
+  const pkgPath = (0, import_path3.join)(dir, "package.json");
+  let framework = "unknown";
+  let router = "unknown";
+  if ((0, import_fs4.existsSync)(pkgPath)) {
+    const pkg = JSON.parse(readFileSafe(pkgPath) || "{}");
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps["next"]) {
+      framework = "nextjs";
+      if ((0, import_fs4.existsSync)((0, import_path3.join)(dir, "app"))) {
+        router = "app-router";
+      } else if ((0, import_fs4.existsSync)((0, import_path3.join)(dir, "pages"))) {
+        router = "pages-router";
+      }
+    } else if (allDeps["nuxt"] || allDeps["nuxt3"]) {
+      framework = "nuxt";
+      router = "file-based";
+    } else if (allDeps["@sveltejs/kit"]) {
+      framework = "sveltekit";
+      router = "file-based";
+    } else if (allDeps["react-router"] || allDeps["react-router-dom"]) {
+      framework = "react-spa";
+      router = "react-router";
+    } else if (allDeps["vue-router"]) {
+      framework = "vue-spa";
+      router = "vue-router";
+    } else if (allDeps["react"]) {
+      framework = "react";
+    } else if (allDeps["vue"]) {
+      framework = "vue";
+    }
+  }
+  return { framework, router };
+}
+function discoverRoutes(dir, framework, router) {
+  const routes = [];
+  if (framework === "nextjs" && router === "app-router") {
+    const appDir = (0, import_path3.join)(dir, "app");
+    if ((0, import_fs4.existsSync)(appDir)) {
+      const pageFiles = walkDir2(appDir, ["page.tsx", "page.jsx", "page.ts", "page.js"]);
+      for (const f of pageFiles) {
+        let route = "/" + (0, import_path3.relative)(appDir, f).replace(/\/page\.(tsx|jsx|ts|js)$/, "").replace(/\([\w-]+\)\//g, "");
+        if (route === "/") route = "/";
+        else route = route.replace(/\/$/, "");
+        routes.push(route);
+      }
+    }
+  } else if (framework === "nextjs" && router === "pages-router") {
+    const pagesDir = (0, import_path3.join)(dir, "pages");
+    if ((0, import_fs4.existsSync)(pagesDir)) {
+      const pageFiles = walkDir2(pagesDir, [".tsx", ".jsx", ".ts", ".js"]);
+      for (const f of pageFiles) {
+        const name = (0, import_path3.basename)(f).replace((0, import_path3.extname)(f), "");
+        if (name.startsWith("_")) continue;
+        let route = "/" + (0, import_path3.relative)(pagesDir, f).replace((0, import_path3.extname)(f), "");
+        if (route === "/index") route = "/";
+        routes.push(route);
+      }
+    }
+  } else {
+    const srcFiles = walkDir2(dir, [".tsx", ".jsx", ".ts", ".js", ".vue", ".svelte"], [], 200);
+    for (const f of srcFiles) {
+      const content = readFileSafe(f);
+      const pathMatches = content.matchAll(/path:\s*['"](\/?[a-z][\w/:-]*)['"]/gi);
+      for (const m of pathMatches) {
+        routes.push(m[1]);
+      }
+    }
+  }
+  return [...new Set(routes)].sort();
+}
+var detectors = {
+  auth(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/createClient|createBrowserClient|createServerClient|supabase\.auth/i, "Supabase Auth", "high"],
+      [/NextAuth|getServerSession|useSession/i, "NextAuth", "high"],
+      [/ClerkProvider|useUser|useAuth.*clerk/i, "Clerk Auth", "high"],
+      [/firebase\.auth|getAuth|onAuthStateChanged/i, "Firebase Auth", "high"],
+      [/auth0|useAuth0|Auth0Provider/i, "Auth0", "high"],
+      [/signIn|signUp|sign_in|sign_up|login|register/i, "Auth flow", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "auth", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  payment(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/stripe|Stripe\(|loadStripe/i, "Stripe", "high"],
+      [/dodo|DodoPayments|DODO_/i, "Dodo Payments", "high"],
+      [/paddle|Paddle\.Setup/i, "Paddle", "high"],
+      [/lemonsqueezy|lemon_squeezy/i, "LemonSqueezy", "high"],
+      [/checkout|createCheckout|payment_intent/i, "Checkout flow", "medium"],
+      [/subscription|plan|pricing/i, "Subscription logic", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "payment", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  onboarding(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/welcome|onboarding|getting.?started/i, "Welcome/Onboarding page", "high"],
+      [/wizard|stepper|step\s*[=:]\s*\d/i, "Multi-step wizard", "medium"],
+      [/profile.?form|setup.?profile|complete.?profile/i, "Profile setup", "medium"],
+      [/tutorial|walkthrough|tour/i, "Tutorial flow", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "onboarding", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  content(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/video|player|YouTube|Vimeo|<video/i, "Video content", "medium"],
+      [/blog|article|post|markdown|mdx/i, "Blog/Content", "medium"],
+      [/IntersectionObserver|scroll.*observer|onScroll/i, "Scroll tracking", "medium"],
+      [/demo|interactive|playground/i, "Interactive demo", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "content", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  pricing(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/monthly|annually|yearly|billing.?cycle/i, "Plan toggle", "high"],
+      [/free|starter|pro|enterprise|indie|startup/i, "Plan names", "medium"],
+      [/upgrade|downgrade|change.?plan/i, "Upgrade prompts", "high"],
+      [/trial|free.?trial|trial.?end/i, "Trial indicator", "high"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "pricing", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  ecommerce(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/cart|addToCart|add.?to.?cart|shopping.?cart/i, "Cart functionality", "high"],
+      [/product|catalog|inventory/i, "Product pages", "medium"],
+      [/checkout|order.?summary|place.?order/i, "Checkout", "high"],
+      [/wishlist|save.?for.?later|favorites/i, "Wishlist", "medium"],
+      [/search|filter|sort.*products/i, "Product search", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "ecommerce", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  forms(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/contact.?form|contact.?us|get.?in.?touch/i, "Contact form", "high"],
+      [/book.?demo|request.?demo|schedule/i, "Demo request", "high"],
+      [/newsletter|subscribe|mailing.?list/i, "Newsletter signup", "medium"],
+      [/gated|download.?form|whitepaper/i, "Gated content", "medium"],
+      [/quiz|calculator|assessment/i, "Quiz/Calculator", "medium"],
+      [/<form|onSubmit|handleSubmit/i, "Form element", "low"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "forms", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  marketplace(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/listing|createListing|my.?listings/i, "Listing management", "high"],
+      [/seller|vendor|merchant/i, "Seller flows", "medium"],
+      [/booking|reservation|appointment/i, "Booking system", "high"],
+      [/review|rating|stars/i, "Review system", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "marketplace", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  community(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/createPost|newPost|post.?editor/i, "Post creation", "high"],
+      [/comment|reply|thread/i, "Comments/Discussion", "medium"],
+      [/invite|referral|share.?link/i, "Invite/Referral", "medium"],
+      [/feed|timeline|activity/i, "Activity feed", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "community", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  },
+  identity(content, _file, relPath) {
+    const results = [];
+    const patterns = [
+      [/callback|auth\/callback|redirect.*auth/i, "Auth callback", "high"],
+      [/login.?success|authenticated|session.?created/i, "Login success", "medium"],
+      [/session.?restore|refresh.?token|token.?refresh/i, "Session restore", "medium"]
+    ];
+    for (const [re, signal, conf] of patterns) {
+      if (re.test(content)) {
+        const line = content.split("\n").findIndex((l) => re.test(l)) + 1;
+        results.push({ category: "identity", signal, file: relPath, line, confidence: conf });
+      }
+    }
+    return results;
+  }
+};
+function runDetectors(dir) {
+  const files = walkDir2(dir, [".tsx", ".jsx", ".ts", ".js", ".vue", ".svelte"]);
+  const allDetections = [];
+  for (const file of files) {
+    const content = readFileSafe(file);
+    if (!content) continue;
+    const relPath = (0, import_path3.relative)(dir, file);
+    for (const detector of Object.values(detectors)) {
+      const results = detector(content, file, relPath);
+      allDetections.push(...results);
+    }
+  }
+  return allDetections;
+}
+function classifyProduct(detections) {
+  const scores = {
+    saas: 0,
+    ecommerce: 0,
+    content: 0,
+    leadgen: 0,
+    marketplace: 0,
+    community: 0,
+    devtools: 0
+  };
+  for (const d of detections) {
+    switch (d.category) {
+      case "auth":
+        scores.saas += 2;
+        scores.devtools += 1;
+        break;
+      case "payment":
+        scores.saas += 3;
+        scores.ecommerce += 2;
+        break;
+      case "pricing":
+        scores.saas += 3;
+        break;
+      case "onboarding":
+        scores.saas += 2;
+        scores.devtools += 1;
+        break;
+      case "ecommerce":
+        scores.ecommerce += 4;
+        break;
+      case "content":
+        scores.content += 3;
+        break;
+      case "forms":
+        scores.leadgen += 2;
+        break;
+      case "marketplace":
+        scores.marketplace += 4;
+        break;
+      case "community":
+        scores.community += 3;
+        break;
+    }
+  }
+  let best = "saas";
+  let bestScore = 0;
+  for (const [type, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      best = type;
+      bestScore = score;
+    }
+  }
+  return { type: best, confidence: Math.min(bestScore / 10, 1) };
+}
+var funnelTemplates = {
+  universal: [
+    {
+      slug: "visitor-to-signup",
+      name: "Visitor \u2192 Signup",
+      steps: [
+        { event_name: "page_view", label: "Landing Page" },
+        { event_name: "signup_cta_clicked", label: "CTA Clicked" },
+        { event_name: "signup_submitted", label: "Signup Submitted" },
+        { event_name: "signup_completed", label: "Signup Completed" }
+      ]
+    }
+  ],
+  saas: [
+    {
+      slug: "trial-to-paid",
+      name: "Trial \u2192 Paid",
+      steps: [
+        { event_name: "pricing_viewed", label: "Pricing Viewed" },
+        { event_name: "plan_selected", label: "Plan Selected" },
+        { event_name: "checkout_started", label: "Checkout Started" },
+        { event_name: "payment_completed", label: "Payment Completed" }
+      ]
+    },
+    {
+      slug: "onboarding-completion",
+      name: "Onboarding Completion",
+      steps: [
+        { event_name: "signup_completed", label: "Signed Up" },
+        { event_name: "onboarding_started", label: "Onboarding Started" },
+        { event_name: "onboarding_completed", label: "Onboarding Completed" }
+      ]
+    }
+  ],
+  ecommerce: [
+    {
+      slug: "browse-to-purchase",
+      name: "Browse \u2192 Purchase",
+      steps: [
+        { event_name: "product_viewed", label: "Product Viewed" },
+        { event_name: "add_to_cart", label: "Added to Cart" },
+        { event_name: "checkout_started", label: "Checkout Started" },
+        { event_name: "purchase_completed", label: "Purchase Completed" }
+      ]
+    },
+    {
+      slug: "cart-abandonment",
+      name: "Cart Abandonment",
+      steps: [
+        { event_name: "add_to_cart", label: "Added to Cart" },
+        { event_name: "cart_viewed", label: "Cart Viewed" },
+        { event_name: "checkout_started", label: "Checkout Started" },
+        { event_name: "purchase_completed", label: "Purchase Completed" }
+      ]
+    }
+  ],
+  content: [
+    {
+      slug: "content-to-signup",
+      name: "Content \u2192 Signup",
+      steps: [
+        { event_name: "article_opened", label: "Article Opened" },
+        { event_name: "scroll_25_pct", label: "Scrolled 25%" },
+        { event_name: "signup_cta_clicked", label: "CTA Clicked" },
+        { event_name: "signup_submitted", label: "Signup Submitted" }
+      ]
+    }
+  ],
+  leadgen: [
+    {
+      slug: "lead-capture",
+      name: "Lead Capture",
+      steps: [
+        { event_name: "page_view", label: "Landing Page" },
+        { event_name: "form_viewed", label: "Form Viewed" },
+        { event_name: "form_focused", label: "Form Focused" },
+        { event_name: "form_submitted", label: "Form Submitted" }
+      ]
+    },
+    {
+      slug: "demo-request",
+      name: "Demo Request",
+      steps: [
+        { event_name: "pricing_viewed", label: "Pricing Viewed" },
+        { event_name: "demo_requested", label: "Demo Requested" }
+      ]
+    }
+  ],
+  marketplace: [
+    {
+      slug: "buyer-journey",
+      name: "Buyer Journey",
+      steps: [
+        { event_name: "search_performed", label: "Search Performed" },
+        { event_name: "listing_viewed", label: "Listing Viewed" },
+        { event_name: "booking_completed", label: "Booking Completed" }
+      ]
+    }
+  ],
+  community: [
+    {
+      slug: "lurker-to-contributor",
+      name: "Lurker \u2192 Contributor",
+      steps: [
+        { event_name: "page_view", label: "Feed Viewed" },
+        { event_name: "post_created", label: "Post Created" },
+        { event_name: "comment_posted", label: "Comment Posted" }
+      ]
+    }
+  ],
+  devtools: [
+    {
+      slug: "docs-to-integration",
+      name: "Docs \u2192 Integration",
+      steps: [
+        { event_name: "page_view", label: "Docs Viewed" },
+        { event_name: "signup_completed", label: "Signed Up" },
+        { event_name: "onboarding_completed", label: "Integration Complete" }
+      ]
+    }
+  ]
+};
+function selectFunnels(productType, detections, existingFunnels) {
+  const existingNames = new Set(existingFunnels.map((f) => f.name?.toLowerCase()));
+  const selected = [];
+  const hasAuth = detections.some((d) => d.category === "auth" && d.confidence === "high");
+  const hasPayment = detections.some((d) => d.category === "payment" && d.confidence === "high");
+  if (hasAuth) {
+    const signup = funnelTemplates.universal[0];
+    if (!existingNames.has(signup.name.toLowerCase())) {
+      selected.push(signup);
+    }
+  }
+  if (hasPayment) {
+    const revenueFunnels = [
+      ...funnelTemplates.saas || [],
+      ...funnelTemplates.ecommerce || []
+    ];
+    const revFunnel = revenueFunnels.find((f) => !existingNames.has(f.name.toLowerCase()));
+    if (revFunnel) selected.push(revFunnel);
+  }
+  const typeFunnels = funnelTemplates[productType.type] || [];
+  for (const f of typeFunnels) {
+    if (selected.length >= 6) break;
+    if (!existingNames.has(f.name.toLowerCase()) && !selected.some((s) => s.slug === f.slug)) {
+      selected.push(f);
+    }
+  }
+  return selected.slice(0, 6);
+}
+
+// src/tools/scan-codebase.ts
+var scanCodebaseDefinition = {
+  name: "scan_codebase",
+  description: "Scan a project directory and report what was found: framework, routes, product type, and detected patterns. Does NOT write any files or create funnels \u2014 just reports findings for the user to review.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      directory: {
+        type: "string",
+        description: "Absolute path to the project root directory"
+      },
+      project_id: {
+        type: "string",
+        description: "EasyFunnel project ID to check existing funnels (optional)"
+      }
+    },
+    required: ["directory"]
+  }
+};
+async function scanCodebase(client2, args) {
+  const dir = args.directory;
+  if (!(0, import_fs5.existsSync)(dir)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Directory "${dir}" does not exist.`
+        }
+      ]
+    };
+  }
+  const { framework, router } = detectFramework(dir);
+  const routes = discoverRoutes(dir, framework, router);
+  const detections = runDetectors(dir);
+  let existingFunnelCount = 0;
+  if (args.project_id) {
+    try {
+      const funnels = await client2.listFunnels(args.project_id);
+      existingFunnelCount = funnels.length;
+    } catch {
+    }
+  }
+  const productType = classifyProduct(detections);
+  const byCategory = {};
+  for (const d of detections) {
+    if (!byCategory[d.category]) byCategory[d.category] = [];
+    byCategory[d.category].push(d);
+  }
+  const categories = Object.keys(byCategory);
+  let report = `SCAN COMPLETE
+
+`;
+  report += `Your project at a glance:
+`;
+  report += `  Framework:    ${framework}${router !== "unknown" ? ` (${router})` : ""}
+`;
+  report += `  Routes found: ${routes.length}
+`;
+  report += `  Product type: ${productType.type} (${Math.round(productType.confidence * 100)}% confidence)
+
+`;
+  report += `What I detected (${detections.length} signals across ${categories.length} categories):
+`;
+  for (const cat of categories) {
+    const signals = byCategory[cat];
+    const uniqueSignals = [...new Set(signals.map((s) => s.signal))];
+    report += `  ${cat.charAt(0).toUpperCase() + cat.slice(1).padEnd(12)}: ${uniqueSignals.join(", ")}
+`;
+  }
+  if (args.project_id) {
+    report += `
+Existing funnels on server: ${existingFunnelCount}
+`;
+  }
+  report += `
+Next: I can set up the SDK in your project, or suggest conversion funnels based on these findings.`;
+  const scanData = {
+    framework,
+    router,
+    routes,
+    product_type: productType.type,
+    product_confidence: productType.confidence,
+    detection_categories: categories,
+    detection_count: detections.length,
+    detections: detections.map((d) => ({
+      category: d.category,
+      signal: d.signal,
+      file: d.file,
+      line: d.line,
+      confidence: d.confidence
+    }))
+  };
+  return {
+    content: [
+      { type: "text", text: report },
+      { type: "text", text: "```json\n" + JSON.stringify(scanData, null, 2) + "\n```" }
+    ]
+  };
+}
+
+// src/tools/validate-setup.ts
+var import_fs6 = require("fs");
+var import_path4 = require("path");
+var validateSetupDefinition = {
+  name: "validate_setup",
+  description: "Verify that the EasyFunnel SDK is correctly set up: checks env var, provider presence, sends a test event, and confirms it arrives in the database.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_root: {
+        type: "string",
+        description: "Absolute path to the project root directory"
+      },
+      project_id: {
+        type: "string",
+        description: "EasyFunnel project ID to verify against"
+      },
+      project_api_key: {
+        type: "string",
+        description: "Project API key (ef_...) \u2014 if not provided, will be read from env file"
+      }
+    },
+    required: ["project_root", "project_id"]
+  }
+};
+function readEnvFile(projectRoot) {
+  const envFiles = [
+    { file: ".env.local", varNames: ["NEXT_PUBLIC_EASYFUNNEL_KEY"] },
+    { file: ".env", varNames: ["VITE_EASYFUNNEL_KEY", "REACT_APP_EASYFUNNEL_KEY", "PUBLIC_EASYFUNNEL_KEY"] }
+  ];
+  for (const { file, varNames } of envFiles) {
+    const envPath = (0, import_path4.join)(projectRoot, file);
+    if (!(0, import_fs6.existsSync)(envPath)) continue;
+    const content = (0, import_fs6.readFileSync)(envPath, "utf-8");
+    for (const varName of varNames) {
+      const match = content.match(new RegExp(`^${varName}=(.+)$`, "m"));
+      if (match) {
+        return { file, varName, value: match[1].trim() };
+      }
+    }
+  }
+  return null;
+}
+function findProviderFile(projectRoot) {
+  const candidates = [
+    "app/layout.tsx",
+    "app/layout.jsx",
+    "src/app/layout.tsx",
+    "src/app/layout.jsx",
+    "src/App.tsx",
+    "src/App.jsx",
+    "src/main.tsx",
+    "src/main.jsx"
+  ];
+  for (const relPath of candidates) {
+    const fullPath = (0, import_path4.join)(projectRoot, relPath);
+    if ((0, import_fs6.existsSync)(fullPath)) {
+      const content = (0, import_fs6.readFileSync)(fullPath, "utf-8");
+      if (content.includes("EasyFunnelProvider")) {
+        return relPath;
+      }
+    }
+  }
+  return null;
+}
+async function validateSetup(client2, args) {
+  const { project_root, project_id } = args;
+  const checks = [];
+  const envResult = readEnvFile(project_root);
+  let apiKey2 = args.project_api_key || "";
+  if (envResult) {
+    apiKey2 = apiKey2 || envResult.value;
+    if (envResult.value && envResult.value.startsWith("ef_")) {
+      checks.push({
+        name: `${envResult.file} contains ${envResult.varName}`,
+        passed: true,
+        detail: `${envResult.varName}=${envResult.value.slice(0, 8)}...`
+      });
+    } else if (envResult.value) {
+      checks.push({
+        name: `${envResult.file} contains ${envResult.varName}`,
+        passed: false,
+        detail: `Value doesn't start with "ef_". Got: ${envResult.value.slice(0, 20)}`
+      });
+    } else {
+      checks.push({
+        name: `${envResult.file} contains ${envResult.varName}`,
+        passed: false,
+        detail: `${envResult.varName} is empty`
+      });
+    }
+  } else {
+    checks.push({
+      name: "Env file contains API key",
+      passed: false,
+      detail: "No EasyFunnel API key found in .env.local or .env"
+    });
+  }
+  const providerFile = findProviderFile(project_root);
+  if (providerFile) {
+    checks.push({
+      name: `EasyFunnelProvider found in ${providerFile}`,
+      passed: true,
+      detail: "Provider is wrapping the app"
+    });
+  } else {
+    checks.push({
+      name: "EasyFunnelProvider found",
+      passed: false,
+      detail: "EasyFunnelProvider not found in any layout or app file"
+    });
+  }
+  if (!apiKey2 || !apiKey2.startsWith("ef_")) {
+    checks.push({
+      name: "Test event sent to /api/collect",
+      passed: false,
+      detail: "Cannot send test event without a valid API key (ef_...)"
+    });
+  } else {
+    const sessionId = `test_${Date.now()}`;
+    try {
+      const result = await client2.sendTestEvent(apiKey2, sessionId);
+      if (result.status === 202) {
+        checks.push({
+          name: "Test event sent to /api/collect",
+          passed: true,
+          detail: `HTTP ${result.status} \u2014 accepted`
+        });
+        await new Promise((r) => setTimeout(r, 2e3));
+        try {
+          const events = await client2.queryEvents(project_id, {
+            query_type: "recent",
+            event_name: "__ef_test",
+            limit: 1
+          });
+          const found = Array.isArray(events) && events.length > 0;
+          checks.push({
+            name: "Test event confirmed in database",
+            passed: found,
+            detail: found ? "Event arrived and is stored" : "Event was accepted but not yet visible in database (may take a moment)"
+          });
+        } catch {
+          checks.push({
+            name: "Test event confirmed in database",
+            passed: false,
+            detail: "Could not query events to verify"
+          });
+        }
+      } else {
+        const hint = result.status === 400 ? "Check your API key is correct." : result.status === 401 ? "API key is invalid." : result.status === 403 ? "Domain may not be whitelisted." : "";
+        checks.push({
+          name: "Test event sent to /api/collect",
+          passed: false,
+          detail: `HTTP ${result.status}. ${hint}`
+        });
+      }
+    } catch (err) {
+      checks.push({
+        name: "Test event sent to /api/collect",
+        passed: false,
+        detail: `Network error: ${err.message}`
+      });
+    }
+  }
+  const allPassed = checks.every((c) => c.passed);
+  const failedChecks = checks.filter((c) => !c.passed);
+  let output = "";
+  if (allPassed) {
+    output += `SETUP VERIFIED
+
+All checks passed:
+`;
+  } else {
+    output += `SETUP CHECK FAILED
+
+`;
+  }
+  for (const check of checks) {
+    const icon = check.passed ? "[pass]" : "[FAIL]";
+    output += `  ${icon} ${check.name}
+`;
+    if (!check.passed) {
+      output += `        ${check.detail}
+`;
+    }
+  }
+  if (allPassed) {
+    output += `
+Your tracking pipeline is working end-to-end.
+`;
+    output += `
+Next: Let me suggest conversion funnels based on what I found in your codebase.`;
+  } else {
+    output += `
+`;
+    for (const check of failedChecks) {
+      if (check.name.includes("Env file") || check.name.includes("API key")) {
+        const varName = envResult?.varName || "NEXT_PUBLIC_EASYFUNNEL_KEY";
+        const envFile = envResult?.file || ".env.local";
+        output += `To fix: Add your project API key to ${envFile}:
+`;
+        output += `  ${varName}=ef_your_key_here
+`;
+        output += `Then restart your dev server.
+
+`;
+      } else if (check.name.includes("Provider")) {
+        output += `To fix: Wrap your app with <EasyFunnelProvider>. Run setup_sdk to do this automatically.
+
+`;
+      }
+    }
+  }
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
+// src/tools/recommend-funnels.ts
+var import_fs7 = require("fs");
+var recommendFunnelsDefinition = {
+  name: "recommend_funnels",
+  description: "Recommend conversion funnels based on product type and detected patterns. Presents choices with WHY explanations for the user to approve before creating.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "EasyFunnel project ID"
+      },
+      product_type: {
+        type: "string",
+        description: "Product type from scan_codebase (saas, ecommerce, content, leadgen, marketplace, community, devtools)"
+      },
+      detection_categories: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Detection categories from scan_codebase (e.g. ["auth", "payment", "pricing"])'
+      },
+      directory: {
+        type: "string",
+        description: "Project directory \u2014 if provided, will re-scan for fresh detections"
+      }
+    },
+    required: ["project_id", "product_type", "detection_categories"]
+  }
+};
+var funnelExplanations = {
+  "visitor-to-signup": "You have auth (login/signup pages). This tracks your top-of-funnel acquisition \u2014 how visitors become users.",
+  "trial-to-paid": "You have payment integration. This is your revenue pipeline \u2014 how users go from browsing pricing to paying.",
+  "onboarding-completion": "You have onboarding flows. This tracks whether new signups actually complete setup and start using the product.",
+  "browse-to-purchase": "You have product pages and checkout. This tracks the full purchase journey from browsing to buying.",
+  "cart-abandonment": "You have cart functionality. This reveals where shoppers drop off between adding items and completing purchase.",
+  "content-to-signup": "You have content/blog pages. This tracks whether your content drives signups \u2014 the content marketing funnel.",
+  "lead-capture": "You have forms. This tracks how visitors interact with your lead capture \u2014 from viewing to submitting.",
+  "demo-request": "You have a pricing page. This tracks the high-intent path from pricing to requesting a demo.",
+  "buyer-journey": "You have listings/search. This tracks the buyer journey from searching to completing a transaction.",
+  "lurker-to-contributor": "You have community features. This tracks the lurker-to-contributor pipeline \u2014 the core community health metric.",
+  "docs-to-integration": "You have developer docs. This tracks whether docs visitors actually integrate \u2014 the devtools growth metric."
+};
+async function recommendFunnels(client2, args) {
+  const { project_id, product_type, detection_categories } = args;
+  let existingFunnels = [];
+  try {
+    existingFunnels = await client2.listFunnels(project_id);
+  } catch {
+  }
+  let detections = [];
+  if (args.directory && (0, import_fs7.existsSync)(args.directory)) {
+    detections = runDetectors(args.directory);
+  } else {
+    for (const cat of detection_categories) {
+      detections.push({
+        category: cat,
+        signal: cat,
+        file: "",
+        line: 0,
+        confidence: "high"
+      });
+    }
+  }
+  const productTypeObj = {
+    type: product_type,
+    confidence: 0.8
+  };
+  const recommended = selectFunnels(productTypeObj, detections, existingFunnels);
+  if (recommended.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `RECOMMENDED FUNNELS
+
+No new funnels to recommend \u2014 you already have ${existingFunnels.length} funnel(s) covering the key flows.
+
+Tip: Use get_funnel_health to check how your existing funnels are performing.`
+        }
+      ]
+    };
+  }
+  let output = `RECOMMENDED FUNNELS
+
+`;
+  output += `Based on your ${product_type} product`;
+  if (detection_categories.length > 0) {
+    output += ` with ${detection_categories.join(" + ")}`;
+  }
+  output += `:
+
+`;
+  for (let i = 0; i < recommended.length; i++) {
+    const funnel = recommended[i];
+    output += `${i + 1}. ${funnel.name}
+`;
+    output += `   ${funnel.steps.map((s) => s.event_name).join(" \u2192 ")}
+`;
+    const why = funnelExplanations[funnel.slug];
+    if (why) {
+      output += `   WHY: ${why}
+`;
+    }
+    output += `
+`;
+  }
+  output += `Which funnels should I create? (all / numbers like "1 and 2" / none)`;
+  const funnelData = recommended.map((f) => ({
+    name: f.name,
+    steps: f.steps
+  }));
+  return {
+    content: [
+      { type: "text", text: output },
+      {
+        type: "text",
+        text: "```json\n" + JSON.stringify({ recommended_funnels: funnelData }, null, 2) + "\n```"
+      }
+    ]
+  };
+}
+
+// src/tools/create-funnels-batch.ts
+function humanizeEventName2(name) {
+  return name.split(/[_-]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+var createFunnelsBatchDefinition = {
+  name: "create_funnels_batch",
+  description: "Create multiple funnels at once. Use after recommend_funnels to create the user-approved funnels.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "EasyFunnel project ID"
+      },
+      funnels: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Funnel name"
+            },
+            steps: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  event_name: { type: "string" },
+                  label: { type: "string" }
+                },
+                required: ["event_name"]
+              },
+              description: "Funnel steps in order"
+            }
+          },
+          required: ["name", "steps"]
+        },
+        description: "Array of funnels to create"
+      }
+    },
+    required: ["project_id", "funnels"]
+  }
+};
+async function createFunnelsBatch(client2, args) {
+  const { project_id, funnels } = args;
+  if (!funnels || funnels.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No funnels provided. Use recommend_funnels first to get suggestions."
+        }
+      ]
+    };
+  }
+  const results = [];
+  for (const funnel of funnels) {
+    try {
+      const stepsWithLabels = funnel.steps.map((s) => ({
+        event_name: s.event_name,
+        label: s.label || humanizeEventName2(s.event_name)
+      }));
+      await client2.createFunnel(project_id, funnel.name, stepsWithLabels);
+      results.push({ name: funnel.name, success: true, stepCount: funnel.steps.length });
+    } catch (err) {
+      results.push({
+        name: funnel.name,
+        success: false,
+        error: err.message,
+        stepCount: funnel.steps.length
+      });
+    }
+  }
+  const created = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+  let output = `FUNNELS CREATED
+
+`;
+  for (const r of results) {
+    if (r.success) {
+      output += `  [created] ${r.name} (${r.stepCount} steps)
+`;
+    } else {
+      output += `  [failed]  ${r.name}: ${r.error}
+`;
+    }
+  }
+  output += `
+`;
+  if (created.length > 0) {
+    output += `${created.length} funnel${created.length > 1 ? "s are" : " is"} now tracking. You'll see conversion data once events flow in.
+`;
+  }
+  if (failed.length > 0) {
+    output += `${failed.length} funnel${failed.length > 1 ? "s" : ""} failed to create. Check the project ID and try again.
+`;
+  }
+  output += `
+Tip: Ask me "how is my signup funnel doing?" to check performance anytime.`;
+  return {
+    content: [{ type: "text", text: output }]
+  };
+}
+
 // src/index.ts
 var apiKey = process.env.EASYFUNNEL_API_KEY;
 if (!apiKey) {
@@ -673,19 +1933,25 @@ if (!apiKey) {
 var baseUrl = process.env.EASYFUNNEL_API_URL || void 0;
 var client = new ApiClient(apiKey, baseUrl);
 var server = new import_server.Server(
-  { name: "easyfunnel", version: "0.1.0" },
+  { name: "easyfunnel", version: "0.2.0" },
   { capabilities: { tools: {} } }
 );
 server.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({
   tools: [
     listProjectsDefinition,
     createProjectDefinition,
+    scanCodebaseDefinition,
     setupSdkDefinition,
+    validateSetupDefinition,
+    recommendFunnelsDefinition,
+    createFunnelsBatchDefinition,
     scanForActionsDefinition,
     instrumentCodeDefinition,
     createFunnelDefinition,
     getFunnelHealthDefinition,
-    queryEventsDefinition
+    queryEventsDefinition,
+    deleteFunnelDefinition,
+    updateFunnelDefinition
   ]
 }));
 server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
@@ -695,8 +1961,16 @@ server.setRequestHandler(import_types.CallToolRequestSchema, async (request) =>
       return listProjects(client);
     case "create_project":
       return createProject(client, args);
+    case "scan_codebase":
+      return scanCodebase(client, args);
     case "setup_sdk":
       return setupSdk(args);
+    case "validate_setup":
+      return validateSetup(client, args);
+    case "recommend_funnels":
+      return recommendFunnels(client, args);
+    case "create_funnels_batch":
+      return createFunnelsBatch(client, args);
     case "scan_for_actions":
       return scanForActions(args);
     case "instrument_code":
@@ -707,6 +1981,10 @@ server.setRequestHandler(import_types.CallToolRequestSchema, async (request) =>
       return getFunnelHealth(client, args);
     case "query_events":
       return queryEvents(client, args);
+    case "delete_funnel":
+      return deleteFunnel(client, args);
+    case "update_funnel":
+      return updateFunnel(client, args);
     default:
       throw new Error(`Unknown tool: ${name}`);
   }