@datalyr/wizard 1.0.0

package/dist/bin/wizard.js

@@ -0,0 +1,2580 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// bin/wizard.ts
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+
+// src/agent/runner.ts
+var p = __toESM(require("@clack/prompts"));
+var import_chalk = __toESM(require("chalk"));
+
+// src/agent/interface.ts
+var AGENT_SIGNALS = {
+  STATUS: "[STATUS]",
+  ERROR_MISSING_KEY: "[ERROR_MISSING_KEY]",
+  ERROR_FAILED: "[ERROR_FAILED]",
+  SUCCESS: "[SUCCESS]"
+};
+var ALLOWED_COMMANDS = [
+  // Package managers
+  "npm",
+  "yarn",
+  "pnpm",
+  "bun",
+  "npx",
+  // Build tools
+  "tsc",
+  "node",
+  // iOS
+  "pod",
+  "xcodebuild",
+  // File operations (read-only)
+  "cat",
+  "ls",
+  "find",
+  "grep",
+  "head",
+  "tail",
+  "wc",
+  // Git (read-only)
+  "git status",
+  "git log",
+  "git diff",
+  "git branch"
+];
+var BLOCKED_PATTERNS = [
+  /;/,
+  // Command chaining
+  /`/,
+  // Backticks
+  /\$\(/,
+  // Command substitution
+  /\|\s*sh/,
+  // Piping to shell
+  /\|\s*bash/,
+  // Piping to bash
+  /rm\s+-rf/,
+  // Dangerous rm
+  />\s*\//,
+  // Overwriting system files
+  /&&\s*rm/
+  // rm after &&
+];
+function validateBashCommand(command) {
+  for (const pattern of BLOCKED_PATTERNS) {
+    if (pattern.test(command)) {
+      return { allowed: false, reason: `Blocked pattern detected: ${pattern}` };
+    }
+  }
+  const baseCommand = command.trim().split(/\s+/)[0];
+  const isAllowed = ALLOWED_COMMANDS.some((allowed) => {
+    if (allowed.includes(" ")) {
+      return command.startsWith(allowed);
+    }
+    return baseCommand === allowed;
+  });
+  if (!isAllowed) {
+    return { allowed: false, reason: `Command not in allowlist: ${baseCommand}` };
+  }
+  return { allowed: true };
+}
+function buildSystemPrompt() {
+  return `<role>
+You are a senior developer specializing in SDK integrations. You have 10+ years of experience integrating analytics tools into React, Next.js, Svelte, React Native, and iOS projects. You are meticulous, always read code before modifying it, and preserve existing functionality.
+</role>
+
+<task>
+Install and configure the Datalyr analytics SDK in the user's project. Complete this task by:
+1. Detecting the framework and understanding the project structure
+2. Installing the correct SDK packages
+3. Creating initialization code in the appropriate entry point
+4. Configuring environment variables
+</task>
+
+<sdks>
+| SDK | Use Case | Install Command |
+|-----|----------|-----------------|
+| @datalyr/web | Browser apps (React, Vue, Svelte, Next.js client) | npm install @datalyr/web |
+| @datalyr/api | Server-side (Next.js API routes, Express, Node) | npm install @datalyr/api |
+| @datalyr/react-native | React Native & Expo mobile apps | npm install @datalyr/react-native |
+| DatalyrSDK | Native iOS Swift apps | Swift Package Manager |
+</sdks>
+
+<rules>
+1. ALWAYS read files before modifying them - never edit blind
+2. PRESERVE existing code - only add Datalyr, never remove functionality
+3. MATCH the project's code style (indentation, quotes, semicolons)
+4. USE TypeScript if the project uses TypeScript
+5. PLACE initialization in the correct entry point for the framework
+6. UPDATE .env or .env.local with NEXT_PUBLIC_DATALYR_WORKSPACE_ID
+7. CHECK for existing Datalyr setup first - don't duplicate
+</rules>
+
+<workflow>
+Step 1: Read package.json to detect framework and package manager
+Step 2: List files to find entry points (app/layout.tsx, src/main.tsx, App.tsx, etc.)
+Step 3: Read entry point files to understand current structure
+Step 4: Install SDK packages using detected package manager
+Step 5: Create initialization file (lib/datalyr.ts or similar)
+Step 6: Update entry point to import and initialize Datalyr
+Step 7: Update or create .env.local with workspace ID placeholder
+Step 8: Call task_complete with summary of changes
+</workflow>
+
+<examples>
+<example name="nextjs-app-router">
+For Next.js 13+ with App Router, create app/providers.tsx:
+\`\`\`tsx
+'use client';
+import datalyr from '@datalyr/web';
+import { useEffect } from 'react';
+
+export function DatalyrProvider({ children }: { children: React.ReactNode }) {
+  useEffect(() => {
+    datalyr.init({
+      workspaceId: process.env.NEXT_PUBLIC_DATALYR_WORKSPACE_ID!,
+      debug: process.env.NODE_ENV === 'development',
+    });
+  }, []);
+  return <>{children}</>;
+}
+\`\`\`
+Then wrap children in app/layout.tsx with <DatalyrProvider>.
+</example>
+
+<example name="react-vite">
+For React + Vite, create src/lib/datalyr.ts:
+\`\`\`ts
+import datalyr from '@datalyr/web';
+
+let initialized = false;
+
+export function initDatalyr() {
+  if (initialized) return;
+  datalyr.init({
+    workspaceId: import.meta.env.VITE_DATALYR_WORKSPACE_ID,
+    debug: import.meta.env.DEV,
+  });
+  initialized = true;
+}
+
+export { datalyr };
+\`\`\`
+Then call initDatalyr() at the top of src/main.tsx.
+</example>
+
+<example name="react-native">
+For React Native, create src/utils/datalyr.ts:
+\`\`\`ts
+import { Datalyr } from '@datalyr/react-native';
+
+export async function initDatalyr(apiKey: string) {
+  await Datalyr.initialize({
+    apiKey,
+    enableAutoEvents: true,
+    debug: __DEV__,
+  });
+}
+
+export { Datalyr };
+\`\`\`
+Then call initDatalyr() in App.tsx useEffect.
+</example>
+</examples>
+
+<signals>
+When complete: ${AGENT_SIGNALS.SUCCESS}
+On error: ${AGENT_SIGNALS.ERROR_FAILED}
+Status updates: ${AGENT_SIGNALS.STATUS} <message>
+</signals>`;
+}
+
+// src/detection/detector.ts
+var import_path2 = __toESM(require("path"));
+
+// src/utils/fs.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_glob = require("glob");
+async function fileExists(filePath) {
+  try {
+    await import_fs_extra.default.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(filePath) {
+  try {
+    return await import_fs_extra.default.readJson(filePath);
+  } catch {
+    return null;
+  }
+}
+async function readPackageJson(cwd) {
+  return readJson(import_path.default.join(cwd, "package.json"));
+}
+async function findFile(cwd, patterns) {
+  for (const pattern of patterns) {
+    const matches = await (0, import_glob.glob)(pattern, { cwd, nodir: true });
+    if (matches.length > 0) {
+      return import_path.default.join(cwd, matches[0]);
+    }
+  }
+  return null;
+}
+
+// src/detection/detector.ts
+async function detectFramework(cwd) {
+  const signals = [];
+  const pkg = await readPackageJson(cwd);
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  if (await fileExists(import_path2.default.join(cwd, "Package.swift"))) {
+    signals.push({ framework: "ios", score: 100, signal: "Package.swift found" });
+  }
+  const xcodeprojs = await findFile(cwd, ["*.xcodeproj", "*.xcworkspace"]);
+  if (xcodeprojs) {
+    signals.push({ framework: "ios", score: 90, signal: "Xcode project found" });
+  }
+  if (!pkg) {
+    const iosScore = signals.filter((s) => s.framework === "ios").reduce((a, b) => a + b.score, 0);
+    if (iosScore > 0) {
+      return buildResult("ios", signals, null);
+    }
+    return buildResult("unknown", [], null);
+  }
+  if (deps.next) {
+    signals.push({ framework: "nextjs", score: 100, signal: "next in dependencies" });
+    if (await fileExists(import_path2.default.join(cwd, "app", "layout.tsx")) || await fileExists(import_path2.default.join(cwd, "app", "layout.js"))) {
+      signals.push({ framework: "nextjs", score: 20, signal: "App Router detected" });
+    }
+    if (await fileExists(import_path2.default.join(cwd, "pages", "_app.tsx")) || await fileExists(import_path2.default.join(cwd, "pages", "_app.js"))) {
+      signals.push({ framework: "nextjs", score: 15, signal: "Pages Router detected" });
+    }
+  }
+  if (deps.expo) {
+    signals.push({ framework: "expo", score: 100, signal: "expo in dependencies" });
+  }
+  if (deps["react-native"] && !deps.expo) {
+    signals.push({ framework: "react-native", score: 100, signal: "react-native in dependencies" });
+  }
+  if (deps["@remix-run/react"] || deps["@remix-run/node"]) {
+    signals.push({ framework: "remix", score: 100, signal: "@remix-run packages found" });
+  }
+  if (deps.astro) {
+    signals.push({ framework: "astro", score: 100, signal: "astro in dependencies" });
+  }
+  if (deps["@sveltejs/kit"]) {
+    signals.push({ framework: "sveltekit", score: 100, signal: "@sveltejs/kit in dependencies" });
+  } else if (deps.svelte) {
+    signals.push({ framework: "svelte", score: 80, signal: "svelte in dependencies" });
+  }
+  if (deps.nuxt) {
+    signals.push({ framework: "nuxt", score: 100, signal: "nuxt in dependencies" });
+  } else if (deps.vue) {
+    signals.push({ framework: "vue", score: 80, signal: "vue in dependencies" });
+  }
+  if (deps.react && deps["react-dom"]) {
+    if (!deps.next && !deps["@remix-run/react"] && !deps["react-native"] && !deps.expo) {
+      if (deps.vite || deps["@vitejs/plugin-react"]) {
+        signals.push({ framework: "react-vite", score: 90, signal: "React + Vite" });
+      } else if (deps["react-scripts"]) {
+        signals.push({ framework: "react", score: 85, signal: "Create React App" });
+      } else {
+        signals.push({ framework: "react", score: 70, signal: "React project" });
+      }
+    }
+  }
+  if (deps.express || deps.fastify || deps.koa || deps.hapi) {
+    if (!deps.react && !deps.vue && !deps.svelte) {
+      signals.push({ framework: "node", score: 80, signal: "Node.js server framework" });
+    }
+  }
+  const frameworkScores = /* @__PURE__ */ new Map();
+  signals.forEach((s) => {
+    const current = frameworkScores.get(s.framework) || 0;
+    frameworkScores.set(s.framework, current + s.score);
+  });
+  let bestFramework = "unknown";
+  let bestScore = 0;
+  frameworkScores.forEach((score, framework) => {
+    if (score > bestScore) {
+      bestScore = score;
+      bestFramework = framework;
+    }
+  });
+  return buildResult(bestFramework, signals, pkg);
+}
+function buildResult(framework, signals, pkg) {
+  const relevantSignals = signals.filter((s) => s.framework === framework).map((s) => s.signal);
+  const confidence = Math.min(100, signals.filter((s) => s.framework === framework).reduce((a, b) => a + b.score, 0));
+  const language = detectLanguage(pkg);
+  const sdks = getSDKsForFramework(framework);
+  const hasAppRouter = framework === "nextjs" && relevantSignals.some((s) => s.includes("App Router"));
+  return {
+    framework,
+    confidence,
+    signals: relevantSignals,
+    sdks,
+    language,
+    hasAppRouter,
+    isExpo: framework === "expo"
+  };
+}
+function detectLanguage(pkg) {
+  if (!pkg) return "javascript";
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  return deps.typescript ? "typescript" : "javascript";
+}
+function getSDKsForFramework(framework) {
+  switch (framework) {
+    case "nextjs":
+    case "remix":
+    case "sveltekit":
+    case "nuxt":
+    case "astro":
+      return ["@datalyr/web", "@datalyr/api"];
+    case "react":
+    case "react-vite":
+    case "svelte":
+    case "vue":
+      return ["@datalyr/web"];
+    case "react-native":
+    case "expo":
+      return ["@datalyr/react-native"];
+    case "ios":
+      return ["DatalyrSDK"];
+    case "node":
+      return ["@datalyr/api"];
+    default:
+      return ["@datalyr/web"];
+  }
+}
+function getFrameworkDisplayName(framework) {
+  const names = {
+    nextjs: "Next.js",
+    react: "React (Create React App)",
+    "react-vite": "React (Vite)",
+    svelte: "Svelte",
+    sveltekit: "SvelteKit",
+    vue: "Vue",
+    nuxt: "Nuxt",
+    remix: "Remix",
+    astro: "Astro",
+    "react-native": "React Native",
+    expo: "Expo",
+    ios: "iOS (Swift)",
+    node: "Node.js",
+    unknown: "Unknown"
+  };
+  return names[framework];
+}
+
+// src/agent/docs/index.ts
+function getFrameworkDocs(framework, apiKey) {
+  switch (framework) {
+    case "nextjs":
+      return getNextjsDocs(apiKey);
+    case "react":
+    case "react-vite":
+      return getReactDocs(apiKey);
+    case "sveltekit":
+      return getSvelteKitDocs(apiKey);
+    case "svelte":
+      return getSvelteDocs(apiKey);
+    case "react-native":
+    case "expo":
+      return getReactNativeDocs(apiKey, framework === "expo");
+    case "ios":
+      return getIOSDocs(apiKey);
+    case "node":
+      return getNodeDocs(apiKey);
+    default:
+      return getGenericWebDocs(apiKey);
+  }
+}
+function getNextjsDocs(apiKey) {
+  return `
+# Datalyr Next.js Integration
+
+## Packages to Install
+- @datalyr/web (client-side tracking)
+- @datalyr/api (server-side tracking)
+
+## Environment Variables
+Add to .env.local:
+\`\`\`
+NEXT_PUBLIC_DATALYR_WORKSPACE_ID=your_workspace_id
+DATALYR_API_KEY=${apiKey}
+\`\`\`
+
+## App Router Setup (Next.js 13+)
+
+### 1. Create Provider Component
+Create \`app/providers.tsx\`:
+\`\`\`tsx
+'use client';
+
+import datalyr from '@datalyr/web';
+import { useEffect } from 'react';
+
+export function DatalyrProvider({ children }: { children: React.ReactNode }) {
+  useEffect(() => {
+    datalyr.init({
+      workspaceId: process.env.NEXT_PUBLIC_DATALYR_WORKSPACE_ID!,
+      debug: process.env.NODE_ENV === 'development',
+      trackSPA: true,
+    });
+  }, []);
+
+  return <>{children}</>;
+}
+\`\`\`
+
+### 2. Wrap Layout
+Update \`app/layout.tsx\` to wrap children with the provider:
+\`\`\`tsx
+import { DatalyrProvider } from './providers';
+
+export default function RootLayout({ children }) {
+  return (
+    <html>
+      <body>
+        <DatalyrProvider>
+          {children}
+        </DatalyrProvider>
+      </body>
+    </html>
+  );
+}
+\`\`\`
+
+### 3. Server-Side Instance (Optional)
+Create \`lib/datalyr.ts\` for server-side tracking:
+\`\`\`ts
+import Datalyr from '@datalyr/api';
+
+export const datalyr = new Datalyr(process.env.DATALYR_API_KEY!);
+\`\`\`
+
+## Pages Router Setup (Legacy)
+
+### 1. Create Hook
+Create \`lib/datalyr.ts\`:
+\`\`\`ts
+import datalyr from '@datalyr/web';
+
+let initialized = false;
+
+export function initDatalyr() {
+  if (initialized || typeof window === 'undefined') return;
+
+  datalyr.init({
+    workspaceId: process.env.NEXT_PUBLIC_DATALYR_WORKSPACE_ID!,
+    debug: process.env.NODE_ENV === 'development',
+    trackSPA: true,
+  });
+
+  initialized = true;
+}
+
+export { datalyr };
+\`\`\`
+
+### 2. Initialize in _app.tsx
+\`\`\`tsx
+import { useEffect } from 'react';
+import { initDatalyr } from '../lib/datalyr';
+
+function MyApp({ Component, pageProps }) {
+  useEffect(() => {
+    initDatalyr();
+  }, []);
+
+  return <Component {...pageProps} />;
+}
+\`\`\`
+`;
+}
+function getReactDocs(apiKey) {
+  return `
+# Datalyr React Integration
+
+## Package to Install
+- @datalyr/web
+
+## Environment Variables
+Add to .env (or .env.local for Vite):
+\`\`\`
+VITE_DATALYR_WORKSPACE_ID=your_workspace_id
+# Or for Create React App:
+REACT_APP_DATALYR_WORKSPACE_ID=your_workspace_id
+\`\`\`
+
+## Setup
+
+### 1. Create Initialization Module
+Create \`src/lib/datalyr.ts\`:
+\`\`\`ts
+import datalyr from '@datalyr/web';
+
+let initialized = false;
+
+export function initDatalyr() {
+  if (initialized || typeof window === 'undefined') return;
+
+  datalyr.init({
+    // Vite uses import.meta.env, CRA uses process.env
+    workspaceId: import.meta.env?.VITE_DATALYR_WORKSPACE_ID ||
+                 process.env.REACT_APP_DATALYR_WORKSPACE_ID,
+    debug: import.meta.env?.DEV || process.env.NODE_ENV === 'development',
+    trackSPA: true,
+  });
+
+  initialized = true;
+}
+
+export { datalyr };
+\`\`\`
+
+### 2. Initialize in Entry Point
+Update \`src/main.tsx\` (Vite) or \`src/index.tsx\` (CRA):
+\`\`\`tsx
+import { initDatalyr } from './lib/datalyr';
+
+// Initialize before rendering
+initDatalyr();
+
+// ... rest of your app setup
+\`\`\`
+
+## Tracking Events
+\`\`\`ts
+import { datalyr } from './lib/datalyr';
+
+// Track an event
+datalyr.track('button_clicked', { button_id: 'signup' });
+
+// Identify a user
+datalyr.identify('user_123', { email: 'user@example.com' });
+\`\`\`
+`;
+}
+function getSvelteKitDocs(apiKey) {
+  return `
+# Datalyr SvelteKit Integration
+
+## Packages to Install
+- @datalyr/web (client-side)
+- @datalyr/api (server-side)
+
+## Environment Variables
+Add to .env:
+\`\`\`
+PUBLIC_DATALYR_WORKSPACE_ID=your_workspace_id
+DATALYR_API_KEY=${apiKey}
+\`\`\`
+
+## Setup
+
+### 1. Client-Side Initialization
+Create \`src/lib/datalyr.ts\`:
+\`\`\`ts
+import datalyr from '@datalyr/web';
+import { browser } from '$app/environment';
+
+let initialized = false;
+
+export function initDatalyr() {
+  if (initialized || !browser) return;
+
+  datalyr.init({
+    workspaceId: import.meta.env.PUBLIC_DATALYR_WORKSPACE_ID,
+    debug: import.meta.env.DEV,
+    trackSPA: true,
+  });
+
+  initialized = true;
+}
+
+export { datalyr };
+\`\`\`
+
+### 2. Initialize in Layout
+Update \`src/routes/+layout.svelte\`:
+\`\`\`svelte
+<script>
+  import { onMount } from 'svelte';
+  import { initDatalyr } from '$lib/datalyr';
+
+  onMount(() => {
+    initDatalyr();
+  });
+</script>
+
+<slot />
+\`\`\`
+
+### 3. Server-Side Instance
+Create \`src/lib/server/datalyr.ts\`:
+\`\`\`ts
+import Datalyr from '@datalyr/api';
+import { DATALYR_API_KEY } from '$env/static/private';
+
+export const datalyr = new Datalyr(DATALYR_API_KEY);
+\`\`\`
+`;
+}
+function getSvelteDocs(apiKey) {
+  return `
+# Datalyr Svelte Integration
+
+## Package to Install
+- @datalyr/web
+
+## Environment Variables
+Add to .env:
+\`\`\`
+VITE_DATALYR_WORKSPACE_ID=your_workspace_id
+\`\`\`
+
+## Setup
+
+### 1. Create Initialization Module
+Create \`src/lib/datalyr.ts\`:
+\`\`\`ts
+import datalyr from '@datalyr/web';
+
+let initialized = false;
+
+export function initDatalyr() {
+  if (initialized || typeof window === 'undefined') return;
+
+  datalyr.init({
+    workspaceId: import.meta.env.VITE_DATALYR_WORKSPACE_ID,
+    debug: import.meta.env.DEV,
+    trackSPA: true,
+  });
+
+  initialized = true;
+}
+
+export { datalyr };
+\`\`\`
+
+### 2. Initialize in App
+Update \`src/App.svelte\`:
+\`\`\`svelte
+<script>
+  import { onMount } from 'svelte';
+  import { initDatalyr } from './lib/datalyr';
+
+  onMount(() => {
+    initDatalyr();
+  });
+</script>
+
+<!-- Your app content -->
+\`\`\`
+`;
+}
+function getReactNativeDocs(_apiKey, isExpo) {
+  const importPath = isExpo ? "@datalyr/react-native/expo" : "@datalyr/react-native";
+  const configImport = isExpo ? "import Constants from 'expo-constants';" : "";
+  const configAccess = isExpo ? "Constants.expoConfig?.extra?.datalyrApiKey || ''" : "process.env.DATALYR_API_KEY || ''";
+  return `
+# Datalyr React Native Integration${isExpo ? " (Expo)" : ""}
+
+## Package to Install
+- @datalyr/react-native
+${isExpo ? "- expo-constants (for config access)" : ""}
+
+## Post-Install (iOS)
+After installing, run:
+\`\`\`bash
+cd ios && pod install
+\`\`\`
+
+## Environment Configuration
+${isExpo ? `
+### For Expo
+Add to \`app.config.js\` or \`app.json\`:
+\`\`\`js
+export default {
+  expo: {
+    extra: {
+      datalyrApiKey: process.env.DATALYR_API_KEY,
+      datalyrWorkspaceId: process.env.DATALYR_WORKSPACE_ID,
+    },
+  },
+};
+\`\`\`
+
+Create \`.env\` file:
+\`\`\`
+DATALYR_API_KEY=your_api_key
+DATALYR_WORKSPACE_ID=your_workspace_id
+\`\`\`
+` : `
+### For React Native CLI
+Create \`.env\` file and use react-native-config:
+\`\`\`
+DATALYR_API_KEY=your_api_key
+DATALYR_WORKSPACE_ID=your_workspace_id
+\`\`\`
+`}
+**Security Note**: Never commit API keys to source control. Use environment variables or secrets management.
+
+## Setup
+
+### 1. Create Initialization Module
+Create \`src/utils/datalyr.ts\`:
+\`\`\`ts
+import { Datalyr } from '${importPath}';
+${configImport}
+
+let initialized = false;
+
+export async function initDatalyr() {
+  if (initialized) return;
+
+  const apiKey = ${configAccess};
+
+  if (!apiKey) {
+    console.warn('[Datalyr] API key not configured');
+    return;
+  }
+
+  await Datalyr.initialize({
+    apiKey,
+    enableAutoEvents: true,
+    enableAttribution: true,
+    debug: __DEV__,
+  });
+
+  initialized = true;
+}
+
+export { Datalyr };
+\`\`\`
+
+### 2. Initialize in App
+Update \`App.tsx\`:
+\`\`\`tsx
+import { useEffect } from 'react';
+import { initDatalyr } from './src/utils/datalyr';
+
+export default function App() {
+  useEffect(() => {
+    initDatalyr();
+  }, []);
+
+  return (
+    // Your app content
+  );
+}
+\`\`\`
+
+## Tracking Events
+\`\`\`ts
+import { Datalyr } from './src/utils/datalyr';
+
+// Track an event
+Datalyr.track('purchase_completed', { amount: 99.99 });
+
+// Identify a user
+Datalyr.identify('user_123', { email: 'user@example.com' });
+\`\`\`
+`;
+}
+function getNodeDocs(apiKey) {
+  return `
+# Datalyr Node.js Integration
+
+## Package to Install
+- @datalyr/api
+
+## Environment Variables
+Add to .env:
+\`\`\`
+DATALYR_API_KEY=${apiKey}
+\`\`\`
+
+## Setup
+
+### 1. Create Datalyr Instance
+Create \`src/lib/datalyr.ts\`:
+\`\`\`ts
+import Datalyr from '@datalyr/api';
+
+const apiKey = process.env.DATALYR_API_KEY;
+if (!apiKey) {
+  throw new Error('DATALYR_API_KEY is required');
+}
+
+export const datalyr = new Datalyr(apiKey);
+\`\`\`
+
+### 2. Track Events
+\`\`\`ts
+import { datalyr } from './lib/datalyr';
+
+// Track server-side events
+await datalyr.track({
+  event: 'order_completed',
+  userId: 'user_123',
+  properties: {
+    orderId: 'order_456',
+    amount: 99.99,
+  },
+});
+
+// Identify a user
+await datalyr.identify({
+  userId: 'user_123',
+  traits: {
+    email: 'user@example.com',
+    plan: 'premium',
+  },
+});
+\`\`\`
+`;
+}
+function getIOSDocs(_apiKey) {
+  return `
+# Datalyr iOS (Swift) Integration
+
+## Package to Install
+Add via Swift Package Manager:
+- https://github.com/datalyr/datalyr-ios-sdk
+
+## Setup
+
+### 1. Add Keys to Info.plist
+Add both keys to your Info.plist (or use xcconfig for different environments):
+\`\`\`xml
+<key>DATALYR_WORKSPACE_ID</key>
+<string>YOUR_WORKSPACE_ID</string>
+<key>DATALYR_API_KEY</key>
+<string>YOUR_API_KEY</string>
+\`\`\`
+
+**Security Note**: For production apps, consider using xcconfig files or build-time environment variables to inject these values, keeping them out of source control.
+
+### 2. Add Configuration File
+Create \`DatalyrConfig.swift\`:
+\`\`\`swift
+import DatalyrSDK
+import Foundation
+
+struct DatalyrConfig {
+    static func initialize() {
+        guard let workspaceId = Bundle.main.object(forInfoDictionaryKey: "DATALYR_WORKSPACE_ID") as? String,
+              let apiKey = Bundle.main.object(forInfoDictionaryKey: "DATALYR_API_KEY") as? String else {
+            #if DEBUG
+            fatalError("DATALYR_WORKSPACE_ID or DATALYR_API_KEY not found in Info.plist")
+            #else
+            print("[Datalyr] Warning: SDK not configured - missing Info.plist keys")
+            return
+            #endif
+        }
+
+        Datalyr.shared.configure(
+            apiKey: apiKey,
+            workspaceId: workspaceId,
+            options: DatalyrOptions(
+                debug: false,
+                enableAutoEvents: true,
+                enableAttribution: true
+            )
+        )
+    }
+}
+\`\`\`
+
+### 3. Initialize in App
+For SwiftUI (\`@main App\`):
+\`\`\`swift
+@main
+struct MyApp: App {
+    init() {
+        DatalyrConfig.initialize()
+    }
+
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+        }
+    }
+}
+\`\`\`
+
+For UIKit (AppDelegate):
+\`\`\`swift
+func application(_ application: UIApplication, didFinishLaunchingWithOptions...) -> Bool {
+    DatalyrConfig.initialize()
+    return true
+}
+\`\`\`
+
+## Tracking Events
+\`\`\`swift
+import DatalyrSDK
+
+// Track an event
+Datalyr.shared.track("purchase_completed", properties: [
+    "amount": 99.99,
+    "currency": "USD"
+])
+
+// Identify a user
+Datalyr.shared.identify("user_123", traits: [
+    "email": "user@example.com",
+    "plan": "premium"
+])
+\`\`\`
+`;
+}
+function getGenericWebDocs(apiKey) {
+  return `
+# Datalyr Web Integration
+
+## Package to Install
+- @datalyr/web
+
+## Setup
+
+### Via NPM
+\`\`\`ts
+import datalyr from '@datalyr/web';
+
+datalyr.init({
+  workspaceId: 'YOUR_WORKSPACE_ID',
+  debug: true,
+});
+
+// Track events
+datalyr.track('page_viewed', { page: '/home' });
+\`\`\`
+
+### Via Script Tag
+\`\`\`html
+<script src="https://track.datalyr.com/dl.js"
+        data-workspace-id="YOUR_WORKSPACE_ID">
+</script>
+\`\`\`
+`;
+}
+
+// src/agent/configs/types.ts
+var NEXTJS_CONFIG = {
+  id: "nextjs",
+  name: "Next.js",
+  detectPackage: "next",
+  sdks: ["@datalyr/web", "@datalyr/api"],
+  envVars: [
+    {
+      key: "NEXT_PUBLIC_DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    },
+    {
+      key: "DATALYR_API_KEY",
+      description: "Server-side API key",
+      isPublic: false
+    }
+  ],
+  estimatedTime: 3,
+  docsUrl: "https://docs.datalyr.com/sdks/nextjs",
+  postInstallSteps: [
+    "Add your workspace ID to .env.local",
+    "Wrap your layout with DatalyrProvider",
+    "Start tracking events with datalyr.track()"
+  ],
+  routerDetection: {
+    appRouter: ["app/layout.tsx", "app/layout.jsx", "app/layout.ts", "app/layout.js"],
+    pagesRouter: ["pages/_app.tsx", "pages/_app.jsx", "pages/_app.ts", "pages/_app.js"]
+  }
+};
+var REACT_CONFIG = {
+  id: "react",
+  name: "React",
+  detectPackage: "react",
+  sdks: ["@datalyr/web"],
+  envVars: [
+    {
+      key: "VITE_DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    }
+  ],
+  estimatedTime: 2,
+  docsUrl: "https://docs.datalyr.com/sdks/react",
+  postInstallSteps: [
+    "Add your workspace ID to .env",
+    "Call initDatalyr() in your main file"
+  ]
+};
+var REACT_NATIVE_CONFIG = {
+  id: "react-native",
+  name: "React Native",
+  detectPackage: "react-native",
+  sdks: ["@datalyr/react-native"],
+  envVars: [],
+  estimatedTime: 5,
+  docsUrl: "https://docs.datalyr.com/sdks/react-native",
+  postInstallSteps: [
+    "Run: cd ios && pod install",
+    "Call initDatalyr() in App.tsx",
+    "For attribution, configure Meta/TikTok app IDs"
+  ]
+};
+var EXPO_CONFIG = {
+  id: "expo",
+  name: "Expo",
+  detectPackage: "expo",
+  sdks: ["@datalyr/react-native"],
+  envVars: [],
+  estimatedTime: 3,
+  docsUrl: "https://docs.datalyr.com/sdks/expo",
+  postInstallSteps: [
+    "Call initDatalyr() in App.tsx",
+    "For attribution, configure Meta/TikTok app IDs in app.json"
+  ]
+};
+var SVELTEKIT_CONFIG = {
+  id: "sveltekit",
+  name: "SvelteKit",
+  detectPackage: "@sveltejs/kit",
+  sdks: ["@datalyr/web", "@datalyr/api"],
+  envVars: [
+    {
+      key: "PUBLIC_DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    },
+    {
+      key: "DATALYR_API_KEY",
+      description: "Server-side API key",
+      isPublic: false
+    }
+  ],
+  estimatedTime: 3,
+  docsUrl: "https://docs.datalyr.com/sdks/sveltekit",
+  postInstallSteps: [
+    "Add your workspace ID to .env",
+    "Call initDatalyr() in +layout.svelte"
+  ]
+};
+var NODE_CONFIG = {
+  id: "node",
+  name: "Node.js",
+  detectPackage: "express",
+  sdks: ["@datalyr/api"],
+  envVars: [
+    {
+      key: "DATALYR_API_KEY",
+      description: "Your Datalyr API key",
+      isPublic: false
+    }
+  ],
+  estimatedTime: 2,
+  docsUrl: "https://docs.datalyr.com/sdks/node",
+  postInstallSteps: [
+    "Add your API key to .env",
+    "Track events with datalyr.track()"
+  ]
+};
+var VUE_CONFIG = {
+  id: "vue",
+  name: "Vue.js",
+  detectPackage: "vue",
+  sdks: ["@datalyr/web"],
+  envVars: [
+    {
+      key: "VITE_DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    }
+  ],
+  estimatedTime: 2,
+  docsUrl: "https://docs.datalyr.com/sdks/vue",
+  postInstallSteps: [
+    "Add your workspace ID to .env",
+    "Call datalyr.init() in main.ts",
+    "Track events with datalyr.track()"
+  ]
+};
+var NUXT_CONFIG = {
+  id: "nuxt",
+  name: "Nuxt",
+  detectPackage: "nuxt",
+  sdks: ["@datalyr/web", "@datalyr/api"],
+  envVars: [
+    {
+      key: "NUXT_PUBLIC_DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    },
+    {
+      key: "DATALYR_API_KEY",
+      description: "Server-side API key",
+      isPublic: false
+    }
+  ],
+  estimatedTime: 3,
+  docsUrl: "https://docs.datalyr.com/sdks/nuxt",
+  postInstallSteps: [
+    "Add your workspace ID to .env",
+    "Create a Nuxt plugin for initialization",
+    "Track events with datalyr.track()"
+  ]
+};
+var REMIX_CONFIG = {
+  id: "remix",
+  name: "Remix",
+  detectPackage: "@remix-run/react",
+  sdks: ["@datalyr/web", "@datalyr/api"],
+  envVars: [
+    {
+      key: "DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    },
+    {
+      key: "DATALYR_API_KEY",
+      description: "Server-side API key",
+      isPublic: false
+    }
+  ],
+  estimatedTime: 3,
+  docsUrl: "https://docs.datalyr.com/sdks/remix",
+  postInstallSteps: [
+    "Add your workspace ID to .env",
+    "Initialize in root.tsx",
+    "Track events with datalyr.track()"
+  ]
+};
+var ASTRO_CONFIG = {
+  id: "astro",
+  name: "Astro",
+  detectPackage: "astro",
+  sdks: ["@datalyr/web"],
+  envVars: [
+    {
+      key: "PUBLIC_DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    }
+  ],
+  estimatedTime: 2,
+  docsUrl: "https://docs.datalyr.com/sdks/astro",
+  postInstallSteps: [
+    "Add your workspace ID to .env",
+    "Add script to Layout component",
+    "Track events with datalyr.track()"
+  ]
+};
+var IOS_CONFIG = {
+  id: "ios",
+  name: "iOS (Swift)",
+  detectPackage: "",
+  // Detected by Package.swift or .xcodeproj
+  sdks: ["DatalyrSDK"],
+  envVars: [
+    {
+      key: "DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID (in Info.plist)",
+      isPublic: false
+    },
+    {
+      key: "DATALYR_API_KEY",
+      description: "Your Datalyr API key (in Info.plist)",
+      isPublic: false
+    }
+  ],
+  estimatedTime: 5,
+  docsUrl: "https://docs.datalyr.com/sdks/ios",
+  postInstallSteps: [
+    "Add DatalyrSDK via Swift Package Manager",
+    "Add keys to Info.plist",
+    "Call DatalyrConfig.initialize() in App init"
+  ]
+};
+var SVELTE_CONFIG = {
+  id: "svelte",
+  name: "Svelte",
+  detectPackage: "svelte",
+  sdks: ["@datalyr/web"],
+  envVars: [
+    {
+      key: "VITE_DATALYR_WORKSPACE_ID",
+      description: "Your Datalyr workspace ID",
+      isPublic: true
+    }
+  ],
+  estimatedTime: 2,
+  docsUrl: "https://docs.datalyr.com/sdks/svelte",
+  postInstallSteps: [
+    "Add your workspace ID to .env",
+    "Call initDatalyr() in App.svelte"
+  ]
+};
+var FRAMEWORK_CONFIGS = {
+  nextjs: NEXTJS_CONFIG,
+  react: REACT_CONFIG,
+  "react-vite": REACT_CONFIG,
+  svelte: SVELTE_CONFIG,
+  sveltekit: SVELTEKIT_CONFIG,
+  vue: VUE_CONFIG,
+  nuxt: NUXT_CONFIG,
+  remix: REMIX_CONFIG,
+  astro: ASTRO_CONFIG,
+  "react-native": REACT_NATIVE_CONFIG,
+  expo: EXPO_CONFIG,
+  ios: IOS_CONFIG,
+  node: NODE_CONFIG,
+  unknown: void 0
+};
+function getSdksForFramework(framework) {
+  const config = FRAMEWORK_CONFIGS[framework];
+  if (!config) {
+    return ["@datalyr/web"];
+  }
+  return config.sdks;
+}
+
+// src/agent/events/suggestions.ts
+var BUSINESS_TYPES = [
+  {
+    id: "saas",
+    label: "SaaS / Web App",
+    description: "Subscription or freemium product",
+    hint: "Trials, signups, features, upgrades"
+  },
+  {
+    id: "mobile_app",
+    label: "Mobile App",
+    description: "Consumer or B2B mobile app",
+    hint: "Installs, in-app events, attribution"
+  },
+  {
+    id: "lead_gen",
+    label: "Lead Gen / Marketing",
+    description: "Capture leads and conversions",
+    hint: "Funnels, forms, demos, signups"
+  },
+  {
+    id: "b2b",
+    label: "B2B Product",
+    description: "Business software",
+    hint: "Demos, trials, team invites, usage"
+  },
+  {
+    id: "agency",
+    label: "Agency / Client Work",
+    description: "Building for clients",
+    hint: "Multi-site, white-label tracking"
+  }
+];
+var EVENT_SUGGESTIONS = {
+  saas: [
+    {
+      name: "signed_up",
+      description: "User created an account",
+      properties: ["method", "referrer"],
+      priority: "high"
+    },
+    {
+      name: "trial_started",
+      description: "User started a free trial",
+      properties: ["plan"],
+      priority: "high"
+    },
+    {
+      name: "subscription_started",
+      description: "User converted to paid",
+      properties: ["plan", "value", "currency"],
+      priority: "high"
+    },
+    {
+      name: "onboarding_completed",
+      description: "User finished onboarding",
+      properties: ["steps_completed"],
+      priority: "medium"
+    }
+  ],
+  mobile_app: [
+    {
+      name: "signed_up",
+      description: "User created an account",
+      properties: ["method", "referrer"],
+      priority: "high"
+    },
+    {
+      name: "onboarding_started",
+      description: "User started onboarding flow",
+      properties: ["source"],
+      priority: "high"
+    },
+    {
+      name: "onboarding_completed",
+      description: "User finished onboarding",
+      properties: ["steps_completed"],
+      priority: "high"
+    },
+    {
+      name: "paywall_viewed",
+      description: "User saw the paywall/pricing",
+      properties: ["source", "paywall_id"],
+      priority: "high"
+    },
+    {
+      name: "trial_started",
+      description: "User started a free trial",
+      properties: ["plan"],
+      priority: "high"
+    },
+    {
+      name: "subscription_started",
+      description: "User converted to paid subscription",
+      properties: ["plan", "value", "currency"],
+      priority: "high"
+    },
+    {
+      name: "purchase",
+      description: "User made in-app purchase",
+      properties: ["product_id", "value", "currency"],
+      priority: "medium"
+    }
+  ],
+  lead_gen: [
+    {
+      name: "lead",
+      description: "User submitted their info",
+      properties: ["form_name", "source"],
+      priority: "high"
+    },
+    {
+      name: "signed_up",
+      description: "User signed up / joined waitlist",
+      properties: ["method", "referrer"],
+      priority: "high"
+    },
+    {
+      name: "demo_requested",
+      description: "User requested a demo",
+      properties: ["product"],
+      priority: "high"
+    },
+    {
+      name: "cta_clicked",
+      description: "User clicked a CTA",
+      properties: ["button_name", "page"],
+      priority: "medium"
+    }
+  ],
+  b2b: [
+    {
+      name: "signed_up",
+      description: "User created an account",
+      properties: ["method", "company_size"],
+      priority: "high"
+    },
+    {
+      name: "demo_requested",
+      description: "User requested a demo",
+      properties: ["product", "company_size"],
+      priority: "high"
+    },
+    {
+      name: "trial_started",
+      description: "User started a trial",
+      properties: ["plan"],
+      priority: "high"
+    },
+    {
+      name: "lead",
+      description: "Lead captured",
+      properties: ["source", "company_size"],
+      priority: "high"
+    }
+  ],
+  agency: [
+    {
+      name: "lead",
+      description: "Lead captured",
+      properties: ["form_name", "client_id"],
+      priority: "high"
+    },
+    {
+      name: "conversion",
+      description: "Conversion event",
+      properties: ["conversion_type", "value", "client_id"],
+      priority: "high"
+    },
+    {
+      name: "form_submitted",
+      description: "User submitted a form",
+      properties: ["form_name", "client_id"],
+      priority: "high"
+    },
+    {
+      name: "cta_clicked",
+      description: "User clicked a CTA",
+      properties: ["button_name", "client_id"],
+      priority: "medium"
+    }
+  ]
+};
+function getEventSuggestions(businessType) {
+  return EVENT_SUGGESTIONS[businessType] || EVENT_SUGGESTIONS.saas;
+}
+function formatEventDescription(event) {
+  const propsDisplay = event.properties.length > 0 ? ` (${event.properties.join(", ")})` : "";
+  return `${event.description}${propsDisplay}`;
+}
+function buildEventSelectOptions(events, includeAllOption = true) {
+  const options = [];
+  if (includeAllOption) {
+    const highPriorityCount = events.filter((e) => e.priority === "high").length;
+    options.push({
+      value: "__all_recommended__",
+      label: "All recommended events",
+      hint: `Select all ${highPriorityCount} high-priority events`
+    });
+  }
+  for (const event of events) {
+    const priorityBadge = event.priority === "high" ? "[recommended] " : "";
+    options.push({
+      value: event.name,
+      label: event.name,
+      hint: `${priorityBadge}${formatEventDescription(event)}`
+    });
+  }
+  return options;
+}
+function resolveSelectedEvents(selectedValues, allEvents) {
+  if (selectedValues.includes("__all_recommended__")) {
+    return allEvents.filter((e) => e.priority === "high");
+  }
+  return allEvents.filter((e) => selectedValues.includes(e.name));
+}
+
+// src/agent/platform/config.ts
+var PLATFORM_TYPES = [
+  {
+    id: "web",
+    label: "Web Only",
+    description: "Website or web application",
+    hint: "React, Next.js, Svelte, etc."
+  },
+  {
+    id: "mobile",
+    label: "Mobile Only",
+    description: "iOS or Android app",
+    hint: "React Native, Expo, Swift"
+  },
+  {
+    id: "both",
+    label: "Web + Mobile",
+    description: "Both web and mobile apps",
+    hint: "Full cross-platform attribution"
+  }
+];
+var AD_PLATFORMS = [
+  {
+    id: "meta",
+    label: "Meta Ads (Facebook/Instagram)",
+    description: "Track conversions from Meta campaigns",
+    requiresServerSide: true,
+    configKeys: ["META_PIXEL_ID", "META_ACCESS_TOKEN", "META_APP_ID"]
+  },
+  {
+    id: "google",
+    label: "Google Ads",
+    description: "Track conversions from Google campaigns",
+    requiresServerSide: true,
+    configKeys: ["GOOGLE_ADS_CUSTOMER_ID", "GOOGLE_ADS_CONVERSION_ID"]
+  },
+  {
+    id: "tiktok",
+    label: "TikTok Ads",
+    description: "Track conversions from TikTok campaigns",
+    requiresServerSide: true,
+    configKeys: ["TIKTOK_PIXEL_ID", "TIKTOK_ACCESS_TOKEN", "TIKTOK_APP_ID"]
+  },
+  {
+    id: "apple_search_ads",
+    label: "Apple Search Ads",
+    description: "Track iOS app install attribution",
+    requiresServerSide: false,
+    configKeys: []
+  },
+  {
+    id: "none",
+    label: "No ad platforms",
+    description: "Skip ad platform setup",
+    requiresServerSide: false,
+    configKeys: []
+  }
+];
+function getSdksForPlatform(platformType, adPlatforms) {
+  const sdks = [];
+  if (platformType === "web" || platformType === "both") {
+    sdks.push("@datalyr/web");
+  }
+  if (platformType === "mobile" || platformType === "both") {
+    sdks.push("@datalyr/react-native");
+  }
+  const needsServerSide = adPlatforms.some(
+    (p2) => AD_PLATFORMS.find((ap) => ap.id === p2)?.requiresServerSide
+  );
+  if (needsServerSide) {
+    sdks.push("@datalyr/api");
+  }
+  return sdks;
+}
+function getAttributionEvents(config) {
+  const events = [];
+  if (config.platformType === "mobile" || config.platformType === "both") {
+    events.push({
+      name: "app_install",
+      description: "User installed the app (auto-tracked)",
+      properties: ["attribution_source", "campaign_id", "ad_group_id"],
+      serverSide: false
+    });
+    events.push({
+      name: "app_open",
+      description: "User opened the app",
+      properties: ["source", "deep_link_url", "is_first_open"],
+      serverSide: false
+    });
+  }
+  if (config.enableDeepLinking) {
+    events.push({
+      name: "deep_link_opened",
+      description: "User opened a deep link",
+      properties: ["url", "source", "campaign"],
+      serverSide: false
+    });
+    events.push({
+      name: "deferred_deep_link",
+      description: "User installed via deferred deep link",
+      properties: ["original_url", "install_time", "open_time"],
+      serverSide: false
+    });
+  }
+  if (config.enableServerSideConversions) {
+    if (config.adPlatforms.includes("meta")) {
+      events.push({
+        name: "purchase",
+        description: "Purchase event for Meta CAPI",
+        properties: ["value", "currency", "email", "phone", "fbc", "fbp"],
+        serverSide: true
+      });
+      events.push({
+        name: "lead",
+        description: "Lead event for Meta CAPI",
+        properties: ["email", "phone", "fbc", "fbp"],
+        serverSide: true
+      });
+    }
+    if (config.adPlatforms.includes("tiktok")) {
+      events.push({
+        name: "complete_payment",
+        description: "Purchase event for TikTok Events API",
+        properties: ["value", "currency", "email", "phone", "ttclid"],
+        serverSide: true
+      });
+    }
+    if (config.adPlatforms.includes("google")) {
+      events.push({
+        name: "conversion",
+        description: "Conversion event for Google Ads",
+        properties: ["value", "currency", "email", "phone", "gclid"],
+        serverSide: true
+      });
+    }
+  }
+  return events;
+}
+function getPlatformPostInstallSteps(config) {
+  const steps = [];
+  if (config.platformType === "mobile" || config.platformType === "both") {
+    steps.push("Run `cd ios && pod install` to install native dependencies");
+    if (config.enableDeepLinking) {
+      steps.push("Configure URL schemes in Xcode/Android manifest for deep linking");
+      steps.push("Set up Associated Domains (iOS) or App Links (Android)");
+    }
+  }
+  for (const platformId of config.adPlatforms) {
+    const platform = AD_PLATFORMS.find((p2) => p2.id === platformId);
+    if (!platform || platformId === "none") continue;
+    steps.push(`Add ${platform.label} credentials to your environment variables`);
+    if (platform.requiresServerSide) {
+      steps.push(`Set up server-side endpoint for ${platform.label} conversions`);
+    }
+    if (config.platformType !== "web") {
+      if (platformId === "meta") {
+        steps.push("Add Meta App ID to Info.plist (iOS) and AndroidManifest.xml");
+      }
+      if (platformId === "tiktok") {
+        steps.push("Add TikTok App ID to Info.plist (iOS) and AndroidManifest.xml");
+      }
+      if (platformId === "apple_search_ads") {
+        steps.push("Enable AdServices.framework in Xcode");
+      }
+    }
+  }
+  return steps;
+}
+
+// src/generators/ai-context.ts
+function inferPropertyType(propName) {
+  const lowerName = propName.toLowerCase();
+  if (["value", "price", "amount", "total", "quantity", "count", "steps_completed"].some((n) => lowerName.includes(n))) {
+    return "number";
+  }
+  if (["is_", "has_", "enable", "disable"].some((n) => lowerName.startsWith(n) || lowerName.includes(n))) {
+    return "boolean";
+  }
+  if (lowerName === "currency") {
+    return 'string; // ISO 4217 code (e.g., "USD", "EUR")';
+  }
+  if (lowerName === "email") {
+    return "string; // User email for attribution matching";
+  }
+  if (lowerName === "phone") {
+    return "string; // User phone for attribution matching";
+  }
+  if (lowerName.endsWith("_id") || lowerName === "id") {
+    return "string";
+  }
+  return "string";
+}
+function generateAIContextDoc(params) {
+  const {
+    workspaceName,
+    workspaceId,
+    framework,
+    platformType,
+    adPlatforms,
+    businessType,
+    selectedEvents,
+    sdks,
+    enableServerSideConversions,
+    enableContainer = true
+  } = params;
+  const eventsList = selectedEvents.map((e) => {
+    const propsWithTypes = e.properties.map((p2) => {
+      const type = inferPropertyType(p2);
+      return `    ${p2}: ${type};`;
+    }).join("\n");
+    return `### \`${e.name}\`
+${e.description}
+
+\`\`\`typescript
+datalyr.track('${e.name}', {
+${propsWithTypes}
+});
+\`\`\``;
+  }).join("\n\n");
+  const trackingExamples = selectedEvents.slice(0, 3).map((e) => {
+    const props = e.properties.slice(0, 2).map((p2) => `${p2}: '...'`).join(", ");
+    return `datalyr.track('${e.name}', { ${props} });`;
+  }).join("\n");
+  const serverSideExample = enableServerSideConversions ? `
+## Server-Side Tracking (CAPI)
+
+For conversion events that need server-side tracking:
+
+\`\`\`typescript
+// In your API route or server action
+import { datalyr } from '@/lib/datalyr.server';
+
+await datalyr.track({
+  event: 'purchase',
+  userId: user.id,
+  properties: {
+    value: 99.00,
+    currency: 'USD',
+    email: user.email,  // Required for ad platform matching
+    phone: user.phone,  // Optional, improves match rate
+  },
+});
+\`\`\`
+` : "";
+  const adPlatformsSection = adPlatforms.length > 0 ? `
+## Attribution Setup
+
+Ad platforms configured: ${adPlatforms.join(", ")}
+
+For proper attribution matching, include user data in conversion events:
+- \`email\`: User's email (hashed automatically)
+- \`phone\`: User's phone number (hashed automatically)
+${adPlatforms.includes("meta") ? "- `fbc`, `fbp`: Meta click/browser IDs (from cookies)" : ""}
+${adPlatforms.includes("google") ? "- `gclid`: Google click ID (from URL params)" : ""}
+${adPlatforms.includes("tiktok") ? "- `ttclid`: TikTok click ID (from URL params)" : ""}
+` : "";
+  const containerSection = enableContainer ? `
+## Container Scripts
+
+Container scripts are **enabled**. Third-party pixels (Meta Pixel, Google Tag, TikTok Pixel)
+are managed through the Datalyr dashboard, not in code.
+
+Configure pixels at: https://app.datalyr.com/dashboard/${workspaceId}/settings/pixels
+
+Benefits:
+- Add/remove pixels without code changes
+- Events tracked with \`datalyr.track()\` auto-fire to all configured pixels
+- Server-side fallback for ad blockers
+` : "";
+  return `# Datalyr Analytics Setup
+
+This file documents the Datalyr analytics configuration for AI coding assistants.
+
+## Project Info
+
+- **Workspace**: ${workspaceName}
+- **Workspace ID**: \`${workspaceId}\`
+- **Framework**: ${framework}
+- **Platform**: ${platformType}
+- **Business Type**: ${businessType}
+- **SDKs**: ${sdks.join(", ")}
+
+## Quick Start
+
+${framework === "ios" ? `\`\`\`swift
+import DatalyrSDK
+
+// Track an event
+Datalyr.shared.track("event_name", properties: ["key": "value"])
+\`\`\`` : `\`\`\`typescript
+import datalyr from '@datalyr/web';
+
+// Track an event
+${trackingExamples}
+\`\`\``}
+
+## Events to Track
+
+${eventsList}
+
+## Usage Patterns
+
+### Identify Users
+
+\`\`\`typescript
+// After user signs in
+datalyr.identify(user.id, {
+  email: user.email,
+  name: user.name,
+  plan: user.plan,
+});
+\`\`\`
+
+### Track Events
+
+\`\`\`typescript
+// Track any event with properties
+datalyr.track('event_name', {
+  property: 'value',
+  value: 100,
+});
+\`\`\`
+${serverSideExample}${adPlatformsSection}${containerSection}
+## Dashboard
+
+View your analytics at:
+https://app.datalyr.com/dashboard/${workspaceId}/events
+
+## Documentation
+
+- SDK Docs: https://docs.datalyr.com/sdks/${framework}
+- API Reference: https://docs.datalyr.com/api
+`;
+}
+
+// src/agent/runner.ts
+var import_promises = require("fs/promises");
+var import_path3 = require("path");
+var import_fs2 = require("fs");
+var import_child_process = require("child_process");
+var import_util = require("util");
+var import_glob2 = require("glob");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+var LLM_GATEWAY_URL = process.env.DATALYR_LLM_GATEWAY || "https://wizard.datalyr.com";
+async function runAgentWizard(_config, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  p.intro(import_chalk.default.cyan("Datalyr AI Wizard"));
+  const useAI = await p.confirm({
+    message: "This wizard uses AI to analyze your project and install Datalyr. Continue?",
+    initialValue: true
+  });
+  if (p.isCancel(useAI) || !useAI) {
+    p.cancel("Wizard cancelled");
+    return { success: false, error: "User cancelled" };
+  }
+  let apiKey = options.apiKey;
+  let workspace = null;
+  let keyAttempts = 0;
+  const maxAttempts = 3;
+  while (!workspace && keyAttempts < maxAttempts) {
+    keyAttempts++;
+    if (!apiKey) {
+      if (keyAttempts === 1) {
+        p.note(
+          `To get your API key:
+  1. Go to ${import_chalk.default.cyan("https://app.datalyr.com/settings/api")}
+  2. Create a new API key (or copy existing)
+  3. Paste it below`,
+          "API Key Required"
+        );
+      }
+      const keyInput = await p.text({
+        message: "Enter your Datalyr API key (starts with dk_):",
+        placeholder: "dk_live_...",
+        validate: (value) => {
+          if (!value) return "API key is required";
+          if (!value.startsWith("dk_")) return "API key must start with dk_";
+          if (value.length < 20) return "API key seems too short";
+          return void 0;
+        }
+      });
+      if (p.isCancel(keyInput)) {
+        p.cancel("Wizard cancelled");
+        return { success: false, error: "User cancelled" };
+      }
+      apiKey = keyInput;
+    }
+    const validateSpinner = p.spinner();
+    validateSpinner.start("Validating API key...");
+    try {
+      const defaultWorkspace = await validateApiKey(apiKey);
+      const allWorkspaces = await fetchWorkspaces(apiKey);
+      if (allWorkspaces.length > 1) {
+        validateSpinner.stop("API key validated");
+        const workspaceChoice = await p.select({
+          message: "Select a workspace to configure:",
+          options: allWorkspaces.map((w) => ({
+            value: w.id,
+            label: w.name,
+            hint: w.domain || void 0
+          }))
+        });
+        if (p.isCancel(workspaceChoice)) {
+          p.cancel("Wizard cancelled");
+          return { success: false, error: "User cancelled" };
+        }
+        const selectedWorkspace = allWorkspaces.find((w) => w.id === workspaceChoice);
+        if (selectedWorkspace) {
+          workspace = {
+            id: selectedWorkspace.id,
+            name: selectedWorkspace.name,
+            timezone: null,
+            domain: selectedWorkspace.domain
+          };
+        } else {
+          workspace = defaultWorkspace;
+        }
+        p.log.info(`Selected workspace: ${import_chalk.default.cyan(workspace.name)}`);
+      } else {
+        workspace = defaultWorkspace;
+        validateSpinner.stop(`Workspace: ${import_chalk.default.cyan(workspace.name)}`);
+      }
+    } catch (error) {
+      validateSpinner.stop(import_chalk.default.red("Invalid API key"));
+      const errorMessage = error instanceof Error ? error.message : "Failed to validate API key";
+      p.log.error(errorMessage);
+      apiKey = void 0;
+      if (keyAttempts < maxAttempts) {
+        const action = await p.select({
+          message: "What would you like to do?",
+          options: [
+            { value: "retry", label: "Try a different API key" },
+            { value: "signup", label: "Create a free account", hint: "Opens browser" },
+            { value: "exit", label: "Exit wizard" }
+          ]
+        });
+        if (p.isCancel(action) || action === "exit") {
+          p.cancel("Wizard cancelled");
+          return { success: false, error: "User cancelled" };
+        }
+        if (action === "signup") {
+          const signupUrl = "https://app.datalyr.com/signup?ref=wizard";
+          p.log.info(`Opening ${import_chalk.default.cyan(signupUrl)} in your browser...`);
+          try {
+            const { exec: exec2 } = await import("child_process");
+            const { promisify: promisify2 } = await import("util");
+            const execAsync2 = promisify2(exec2);
+            const platform = process.platform;
+            const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+            await execAsync2(`${cmd} "${signupUrl}"`);
+            p.log.success("Browser opened! Create your account and come back with your API key.");
+            await p.text({
+              message: "Press Enter when you have your API key ready..."
+            });
+          } catch {
+            p.log.warn(`Please visit: ${import_chalk.default.cyan(signupUrl)}`);
+          }
+        }
+      }
+    }
+  }
+  if (!workspace || !apiKey) {
+    p.log.error(`Failed to validate API key after ${maxAttempts} attempts.`);
+    p.log.info(`Get help at ${import_chalk.default.cyan("https://docs.datalyr.com/getting-started")}`);
+    return { success: false, error: "API key validation failed" };
+  }
+  const validatedApiKey = apiKey;
+  const detectSpinner = p.spinner();
+  detectSpinner.start("Analyzing your project...");
+  let detection = await detectFramework(cwd);
+  let framework = detection.framework;
+  if (framework === "unknown" && !options.framework) {
+    detectSpinner.stop("Could not auto-detect framework");
+    const frameworkChoice = await p.select({
+      message: "Select your framework:",
+      options: [
+        { value: "nextjs", label: "Next.js" },
+        { value: "react", label: "React" },
+        { value: "react-vite", label: "React (Vite)" },
+        { value: "svelte", label: "Svelte" },
+        { value: "sveltekit", label: "SvelteKit" },
+        { value: "react-native", label: "React Native" },
+        { value: "expo", label: "Expo" },
+        { value: "ios", label: "iOS (Swift)" },
+        { value: "node", label: "Node.js" }
+      ]
+    });
+    if (p.isCancel(frameworkChoice)) {
+      p.cancel("Wizard cancelled");
+      return { success: false, error: "User cancelled" };
+    }
+    framework = frameworkChoice;
+  } else if (options.framework) {
+    framework = options.framework;
+  }
+  detectSpinner.stop(`Detected: ${import_chalk.default.cyan(getFrameworkDisplayName(framework))}`);
+  if (detection.framework !== framework) {
+    detection = { ...detection, framework, sdks: getSdksForFramework(framework) };
+  }
+  const isMobileFramework = ["react-native", "expo", "ios"].includes(framework);
+  const isWebFramework = ["nextjs", "react", "react-vite", "svelte", "sveltekit"].includes(framework);
+  let platformType = "web";
+  if (isMobileFramework) {
+    platformType = "mobile";
+  } else if (!isMobileFramework && !isWebFramework) {
+    const platformChoice = await p.select({
+      message: "What platforms are you targeting?",
+      options: PLATFORM_TYPES.map((type) => ({
+        value: type.id,
+        label: type.label,
+        hint: type.hint
+      }))
+    });
+    if (p.isCancel(platformChoice)) {
+      p.cancel("Wizard cancelled");
+      return { success: false, error: "User cancelled" };
+    }
+    platformType = platformChoice;
+  }
+  const runningAds = await p.confirm({
+    message: "Are you running paid ads (Meta, Google, TikTok)?",
+    initialValue: false
+  });
+  let adPlatforms = [];
+  let platformConfig = {
+    platformType,
+    adPlatforms: [],
+    enableDeepLinking: false,
+    enableServerSideConversions: false
+  };
+  if (!p.isCancel(runningAds) && runningAds) {
+    const adPlatformChoices = await p.multiselect({
+      message: "Select your ad platforms:",
+      options: AD_PLATFORMS.filter((p2) => p2.id !== "none").map((platform) => ({
+        value: platform.id,
+        label: platform.label,
+        hint: platform.description
+      })),
+      required: false
+    });
+    if (!p.isCancel(adPlatformChoices)) {
+      adPlatforms = adPlatformChoices;
+      if (adPlatforms.length > 0) {
+        const serverSide = await p.confirm({
+          message: "Enable server-side conversion tracking (CAPI)?",
+          initialValue: true
+        });
+        platformConfig.enableServerSideConversions = !p.isCancel(serverSide) && serverSide;
+      }
+    }
+  }
+  if (platformType === "mobile" || platformType === "both") {
+    const deepLinking = await p.confirm({
+      message: "Set up deep linking / deferred deep links?",
+      initialValue: adPlatforms.length > 0
+    });
+    platformConfig.enableDeepLinking = !p.isCancel(deepLinking) && deepLinking;
+  }
+  platformConfig.adPlatforms = adPlatforms;
+  let enableContainer = options.enableContainer;
+  if (enableContainer === void 0 && platformType !== "mobile") {
+    const containerChoice = await p.confirm({
+      message: "Manage third-party pixels through Datalyr dashboard?",
+      initialValue: adPlatforms.length > 0
+      // Default yes if using ad platforms
+    });
+    if (!p.isCancel(containerChoice)) {
+      enableContainer = containerChoice;
+      if (containerChoice) {
+        p.note(
+          `Container scripts let you:
+  ${import_chalk.default.green("\u2022")} Add/remove Meta, Google, TikTok pixels without code
+  ${import_chalk.default.green("\u2022")} Auto-fire datalyr.track() events to all pixels
+  ${import_chalk.default.green("\u2022")} Inject custom scripts (Hotjar, Intercom, etc.)`,
+          "Container Scripts"
+        );
+      }
+    }
+  }
+  const containerEnabled = enableContainer !== false;
+  const businessTypeChoice = await p.select({
+    message: "What type of app are you building?",
+    options: BUSINESS_TYPES.map((type) => ({
+      value: type.id,
+      label: type.label,
+      hint: type.hint
+    }))
+  });
+  if (p.isCancel(businessTypeChoice)) {
+    p.cancel("Wizard cancelled");
+    return { success: false, error: "User cancelled" };
+  }
+  const selectedBusinessType = businessTypeChoice;
+  const suggestedEvents = getEventSuggestions(selectedBusinessType);
+  const attributionEvents = getAttributionEvents(platformConfig);
+  const autoTrackedEvents = platformType === "mobile" || platformType === "both" ? ["page_view / screen_view", "session_start", "app_install (mobile)", "attribution data"] : ["page_view", "session_start", "referrer", "UTM parameters"];
+  p.note(
+    `${import_chalk.default.bold("Auto-tracked (no code needed):")}
+` + autoTrackedEvents.map((e) => `  ${import_chalk.default.dim("\u2022")} ${e}`).join("\n") + `
+
+${import_chalk.default.bold("High-value events")} are the key actions that matter for your business:
+  ${import_chalk.default.dim("\u2022")} Conversions (signups, purchases, leads)
+  ${import_chalk.default.dim("\u2022")} Engagement (feature usage, key interactions)
+  ${import_chalk.default.dim("\u2022")} Revenue (transactions, subscriptions)`,
+    "Event Tracking"
+  );
+  const allEvents = [...suggestedEvents, ...attributionEvents.map((e) => ({
+    name: e.name,
+    description: e.description,
+    properties: e.properties,
+    priority: "high"
+  }))];
+  const uniqueEvents = allEvents.filter(
+    (event, index, self) => index === self.findIndex((e) => e.name === event.name)
+  );
+  const eventOptions = buildEventSelectOptions(uniqueEvents, true);
+  const businessTypeLabel = BUSINESS_TYPES.find((b) => b.id === selectedBusinessType)?.label || selectedBusinessType;
+  p.note(
+    `Based on your ${import_chalk.default.cyan(businessTypeLabel)} app, we suggest these events:
+
+` + uniqueEvents.filter((e) => e.priority === "high").map((e) => `  ${import_chalk.default.green("\u2022")} ${import_chalk.default.bold(e.name)}: ${formatEventDescription(e)}`).join("\n"),
+    "Suggested Events"
+  );
+  const selectedEventNames = await p.multiselect({
+    message: "Select events to track:",
+    options: eventOptions,
+    initialValues: ["__all_recommended__"],
+    required: false
+  });
+  let selectedEvents = p.isCancel(selectedEventNames) ? uniqueEvents.filter((e) => e.priority === "high") : resolveSelectedEvents(selectedEventNames, uniqueEvents);
+  const addCustom = await p.confirm({
+    message: "Want to add any custom events specific to your app?",
+    initialValue: false
+  });
+  if (!p.isCancel(addCustom) && addCustom) {
+    const customEventInput = await p.text({
+      message: "Enter custom event names (comma-separated):",
+      placeholder: "checkout_completed, feature_clicked, ..."
+    });
+    if (!p.isCancel(customEventInput) && customEventInput) {
+      const customEvents = customEventInput.split(",").map((e) => e.trim()).filter((e) => e.length > 0).map((name) => ({
+        name,
+        description: "Custom event",
+        properties: ["value", "context"],
+        priority: "high"
+      }));
+      selectedEvents = [...selectedEvents, ...customEvents];
+    }
+  }
+  if (selectedEvents.length > 0) {
+    const eventList = selectedEvents.slice(0, 6).map((e) => `  ${import_chalk.default.green("\u2022")} ${import_chalk.default.bold(e.name)}`).join("\n");
+    const moreCount = selectedEvents.length > 6 ? ` (+${selectedEvents.length - 6} more)` : "";
+    p.note(
+      `Events you'll track:
+
+${eventList}${moreCount}`,
+      "Your Events"
+    );
+  }
+  const platformSdks = getSdksForPlatform(platformType, adPlatforms);
+  const allSdks = [.../* @__PURE__ */ new Set([...detection.sdks, ...platformSdks])];
+  const platformSteps = getPlatformPostInstallSteps(platformConfig);
+  p.note(
+    `The wizard will:
+${import_chalk.default.green("\u2022")} Install ${import_chalk.default.cyan(allSdks.join(", "))}
+${import_chalk.default.green("\u2022")} Create initialization code
+${import_chalk.default.green("\u2022")} Configure environment variables
+${import_chalk.default.green("\u2022")} Set up workspace: ${import_chalk.default.cyan(workspace.name)}
+${adPlatforms.length > 0 ? `${import_chalk.default.green("\u2022")} Configure attribution for: ${import_chalk.default.cyan(adPlatforms.join(", "))}` : ""}
+${containerEnabled && platformType !== "mobile" ? `${import_chalk.default.green("\u2022")} Enable container scripts for pixel management` : ""}`,
+    "Installation Plan"
+  );
+  const proceed = await p.confirm({
+    message: "Proceed with installation?",
+    initialValue: true
+  });
+  if (p.isCancel(proceed) || !proceed) {
+    p.cancel("Wizard cancelled");
+    return { success: false, error: "User cancelled" };
+  }
+  const agentSpinner = p.spinner();
+  agentSpinner.start("AI agent is working...");
+  try {
+    const result = await executeAgent({
+      framework,
+      apiKey: validatedApiKey,
+      cwd,
+      docs: getFrameworkDocs(framework, validatedApiKey),
+      debug: options.debug,
+      enableContainer: containerEnabled,
+      workspaceId: workspace.id
+    });
+    if (result.success) {
+      agentSpinner.stop(import_chalk.default.green("Installation complete!"));
+      if (!options.skipVerification) {
+        const verifyResult = await verifyInstallation(validatedApiKey, workspace.id);
+        if (verifyResult.success) {
+          p.log.success("SDK verified and ready to track events!");
+        } else {
+          p.log.warn("Could not verify SDK installation. This may be normal if events haven't been sent yet.");
+          p.log.info(`Check your dashboard at: ${import_chalk.default.cyan(`https://app.datalyr.com/dashboard/${workspace.id}/events`)}`);
+        }
+      }
+      try {
+        const aiContextDoc = generateAIContextDoc({
+          workspaceName: workspace.name,
+          workspaceId: workspace.id,
+          framework,
+          platformType,
+          adPlatforms,
+          businessType: selectedBusinessType,
+          selectedEvents,
+          sdks: allSdks,
+          enableServerSideConversions: platformConfig.enableServerSideConversions,
+          enableContainer: containerEnabled
+        });
+        await (0, import_promises.writeFile)((0, import_path3.join)(cwd, ".datalyr.md"), aiContextDoc);
+        p.log.success("Created .datalyr.md for AI coding assistants");
+      } catch {
+      }
+      const eventExamples = selectedEvents.slice(0, 3).map(
+        (e) => `datalyr.track('${e.name}', { ${e.properties.slice(0, 2).map((p2) => `${p2}: '...'`).join(", ")} })`
+      ).join("\n  ");
+      const stepsText = platformSteps.length > 0 ? `
+
+${import_chalk.default.bold("Next steps:")}
+${platformSteps.map((s) => `  ${import_chalk.default.yellow("\u2192")} ${s}`).join("\n")}` : "";
+      p.note(
+        `Your workspace "${workspace.name}" is ready!
+
+${import_chalk.default.bold("Start tracking events:")}
+  ${eventExamples || "datalyr.track('event_name', { property: 'value' })"}
+
+${import_chalk.default.bold("View your data:")}
+  ${import_chalk.default.cyan(`https://app.datalyr.com/dashboard/${workspace.id}/events`)}${stepsText}`,
+        "Success!"
+      );
+      p.outro(import_chalk.default.green("Datalyr is ready to use!"));
+    } else {
+      agentSpinner.stop(import_chalk.default.red("Installation failed"));
+      p.log.error(result.error || "Unknown error");
+    }
+    return result;
+  } catch (error) {
+    agentSpinner.stop(import_chalk.default.red("Agent error"));
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    p.log.error(errorMessage);
+    return { success: false, error: errorMessage };
+  }
+}
+async function executeAgent(params) {
+  const { framework, apiKey, cwd, docs, debug, enableContainer = true, workspaceId } = params;
+  const initialMessage = buildIntegrationPrompt(framework, apiKey, docs, enableContainer, workspaceId);
+  const messages = [
+    { role: "user", content: initialMessage }
+  ];
+  const filesModified = [];
+  const maxIterations = 20;
+  let iterations = 0;
+  while (iterations < maxIterations) {
+    iterations++;
+    if (debug) {
+      console.log(`[DEBUG] Agent iteration ${iterations}`);
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 6e4);
+      const response = await fetch(`${LLM_GATEWAY_URL}/agent`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          messages,
+          system: buildSystemPrompt()
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.text();
+        return { success: false, error: `Gateway error: ${error}` };
+      }
+      const claudeResponse = await response.json();
+      if (debug) {
+        console.log("[DEBUG] Response:", JSON.stringify(claudeResponse, null, 2));
+      }
+      messages.push({ role: "assistant", content: claudeResponse.content });
+      if (claudeResponse.stop_reason === "end_turn") {
+        const taskComplete = claudeResponse.content.find(
+          (block) => block.type === "tool_use" && block.name === "task_complete"
+        );
+        if (taskComplete) {
+          const input = taskComplete.input;
+          return {
+            success: input.success,
+            message: input.summary,
+            filesModified: input.files_modified || filesModified
+          };
+        }
+        if (filesModified.length > 0) {
+          return {
+            success: false,
+            message: "Agent stopped unexpectedly. Files were modified but installation may be incomplete.",
+            error: "Agent did not call task_complete. Please verify the installation manually.",
+            filesModified
+          };
+        }
+        return {
+          success: false,
+          error: "Agent stopped without completing the installation task."
+        };
+      }
+      if (claudeResponse.stop_reason === "tool_use") {
+        const toolUseBlocks = claudeResponse.content.filter(
+          (block) => block.type === "tool_use"
+        );
+        const toolResults = [];
+        for (const toolUse of toolUseBlocks) {
+          if (toolUse.name === "task_complete") {
+            const input = toolUse.input;
+            return {
+              success: input.success,
+              message: input.summary,
+              filesModified: input.files_modified || filesModified
+            };
+          }
+          const result = await executeTool(toolUse, cwd, debug);
+          if (toolUse.name === "write_file" && !result.is_error) {
+            const path3 = toolUse.input.path;
+            if (!filesModified.includes(path3)) {
+              filesModified.push(path3);
+            }
+          }
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: toolUse.id,
+            content: result.content,
+            is_error: result.is_error
+          });
+        }
+        messages.push({ role: "user", content: toolResults });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (debug) {
+        console.error("[DEBUG] Agent error:", error);
+      }
+      return { success: false, error: `Agent error: ${errorMessage}` };
+    }
+  }
+  return { success: false, error: "Agent exceeded maximum iterations" };
+}
+function isPathSafe(basePath, targetPath) {
+  const resolvedBase = (0, import_path3.resolve)(basePath);
+  const resolvedTarget = (0, import_path3.resolve)(basePath, targetPath);
+  return resolvedTarget.startsWith(resolvedBase + "/") || resolvedTarget === resolvedBase;
+}
+async function executeTool(toolUse, cwd, debug) {
+  const { name, input } = toolUse;
+  if (debug) {
+    console.log(`[DEBUG] Executing tool: ${name}`, input);
+  }
+  try {
+    switch (name) {
+      case "read_file": {
+        if (typeof input.path !== "string" || !input.path.trim()) {
+          return { content: "Error: path must be a non-empty string", is_error: true };
+        }
+        const path3 = input.path.trim();
+        if (!isPathSafe(cwd, path3)) {
+          return { content: "Error: path traversal detected - access denied", is_error: true };
+        }
+        const fullPath = (0, import_path3.join)(cwd, path3);
+        const content = await (0, import_promises.readFile)(fullPath, "utf-8");
+        return { content };
+      }
+      case "write_file": {
+        if (typeof input.path !== "string" || !input.path.trim()) {
+          return { content: "Error: path must be a non-empty string", is_error: true };
+        }
+        if (typeof input.content !== "string") {
+          return { content: "Error: content must be a string", is_error: true };
+        }
+        const path3 = input.path.trim();
+        const content = input.content;
+        if (!isPathSafe(cwd, path3)) {
+          return { content: "Error: path traversal detected - access denied", is_error: true };
+        }
+        const fullPath = (0, import_path3.join)(cwd, path3);
+        const dir = (0, import_path3.dirname)(fullPath);
+        if (!(0, import_fs2.existsSync)(dir)) {
+          await (0, import_promises.mkdir)(dir, { recursive: true });
+        }
+        await (0, import_promises.writeFile)(fullPath, content, "utf-8");
+        return { content: `Successfully wrote ${path3}` };
+      }
+      case "run_command": {
+        if (typeof input.command !== "string" || !input.command.trim()) {
+          return { content: "Error: command must be a non-empty string", is_error: true };
+        }
+        const command = input.command.trim();
+        const validation = validateBashCommand(command);
+        if (!validation.allowed) {
+          return {
+            content: `Command blocked: ${validation.reason}`,
+            is_error: true
+          };
+        }
+        const { stdout, stderr } = await execAsync(command, { cwd, timeout: 12e4 });
+        return { content: stdout || stderr || "Command completed successfully" };
+      }
+      case "list_files": {
+        if (typeof input.path !== "string") {
+          return { content: "Error: path must be a string", is_error: true };
+        }
+        const path3 = input.path.trim() || ".";
+        const pattern = typeof input.pattern === "string" ? input.pattern : "*";
+        if (!isPathSafe(cwd, path3)) {
+          return { content: "Error: path traversal detected - access denied", is_error: true };
+        }
+        const fullPath = (0, import_path3.join)(cwd, path3);
+        const files = await (0, import_glob2.glob)(pattern, {
+          cwd: fullPath,
+          nodir: false,
+          maxDepth: 3
+        });
+        return { content: files.slice(0, 100).join("\n") };
+      }
+      default:
+        return { content: `Unknown tool: ${name}`, is_error: true };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return { content: `Error: ${errorMessage}`, is_error: true };
+  }
+}
+function buildIntegrationPrompt(framework, apiKey, docs, enableContainer, workspaceId) {
+  const containerConfig = enableContainer ? "  enableContainer: true,  // Load third-party pixels from Datalyr dashboard" : "  enableContainer: false, // Container scripts disabled";
+  const envVarName = framework === "nextjs" ? "NEXT_PUBLIC_DATALYR_WORKSPACE_ID" : framework === "sveltekit" ? "PUBLIC_DATALYR_WORKSPACE_ID" : framework.startsWith("react") && framework !== "react-native" ? "VITE_DATALYR_WORKSPACE_ID" : "DATALYR_WORKSPACE_ID";
+  return `Install Datalyr analytics into this ${getFrameworkDisplayName(framework)} project.
+
+## Workspace ID
+${workspaceId}
+
+## API Key (for server-side only)
+${apiKey}
+
+## Integration Documentation
+${docs}
+
+## SDK Configuration
+When initializing the SDK, use these options:
+\`\`\`typescript
+datalyr.init({
+  workspaceId: process.env.${envVarName},
+${containerConfig}
+});
+\`\`\`
+
+## Environment Variable
+Add to .env.local (or .env):
+${envVarName}=${workspaceId}
+
+## Your Task
+
+1. Read package.json to understand the project
+2. Install the SDK: run the appropriate install command
+3. Create initialization code following the documentation
+4. Add the environment variable to .env.local or .env
+5. Call task_complete when done
+
+Start by reading package.json.`;
+}
+async function validateApiKey(apiKey) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 3e4);
+  const response = await fetch(`${LLM_GATEWAY_URL}/validate-key`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ apiKey }),
+    signal: controller.signal
+  });
+  clearTimeout(timeoutId);
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || "Failed to validate API key");
+  }
+  const result = await response.json();
+  if (!result.success || !result.workspace) {
+    throw new Error(result.error || "Invalid API key");
+  }
+  return result.workspace;
+}
+async function fetchWorkspaces(apiKey) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 3e4);
+  const response = await fetch(`${LLM_GATEWAY_URL}/workspaces`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ apiKey }),
+    signal: controller.signal
+  });
+  clearTimeout(timeoutId);
+  if (!response.ok) {
+    return [];
+  }
+  const result = await response.json();
+  if (!result.success || !result.workspaces) {
+    return [];
+  }
+  return result.workspaces;
+}
+async function verifyInstallation(apiKey, workspaceId) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 15e3);
+    const response = await fetch(`${LLM_GATEWAY_URL}/verify`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ apiKey, workspaceId }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return { success: false };
+    }
+    const result = await response.json();
+    return result;
+  } catch {
+    return { success: false };
+  }
+}
+
+// bin/wizard.ts
+var validFrameworks = [
+  "nextjs",
+  "react",
+  "react-vite",
+  "svelte",
+  "sveltekit",
+  "react-native",
+  "expo",
+  "ios",
+  "node"
+];
+async function main() {
+  const argv = await (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).scriptName("datalyr-wizard").usage("$0 [options]").option("api-key", {
+    alias: "k",
+    type: "string",
+    description: "Your Datalyr API key (starts with dk_)"
+  }).option("framework", {
+    alias: "f",
+    type: "string",
+    choices: validFrameworks,
+    description: "Framework to configure"
+  }).option("skip-verification", {
+    type: "boolean",
+    default: false,
+    description: "Skip post-install verification"
+  }).option("enable-container", {
+    type: "boolean",
+    description: "Enable/disable container scripts for pixel management"
+  }).option("debug", {
+    type: "boolean",
+    default: false,
+    description: "Enable debug output"
+  }).option("cwd", {
+    type: "string",
+    description: "Working directory (defaults to current)"
+  }).example("$0", "Run interactive wizard").example("$0 --api-key dk_xxx", "Pre-fill API key").example("$0 --framework nextjs", "Force Next.js configuration").help().alias("help", "h").version().alias("version", "v").parse();
+  const options = {
+    apiKey: argv["api-key"],
+    framework: argv.framework,
+    skipVerification: argv["skip-verification"],
+    enableContainer: argv["enable-container"],
+    debug: argv.debug,
+    cwd: argv.cwd
+  };
+  const result = await runAgentWizard(NEXTJS_CONFIG, options);
+  process.exit(result.success ? 0 : 1);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=wizard.js.map