@datalyr/wizard 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -228,6 +228,8 @@ function getInstallCommand(pm, packages, dev = false) {
       return dev ? `pnpm add -D ${pkgList}` : `pnpm add ${pkgList}`;
     case "bun":
       return dev ? `bun add -d ${pkgList}` : `bun add ${pkgList}`;
+    default:
+      return dev ? `npm install -D ${pkgList}` : `npm install ${pkgList}`;
   }
 }
 
@@ -453,29 +455,39 @@ export { datalyr };
 
 // src/generators/templates/react-native.ts
 function generateReactNativeFiles(options) {
-  const { language, isExpo, apiKey } = options;
+  const { language, isExpo } = options;
   const ext = language === "typescript" ? "ts" : "js";
   return [
     {
       path: `src/utils/datalyr.${ext}`,
       action: "create",
       description: "Datalyr initialization",
-      content: generateReactNativeInit(language, isExpo, apiKey)
+      content: generateReactNativeInit(language, isExpo)
     }
   ];
 }
-function generateReactNativeInit(language, isExpo, apiKey) {
+function generateReactNativeInit(language, isExpo) {
   const importPath = isExpo ? "@datalyr/react-native/expo" : "@datalyr/react-native";
   if (language === "typescript") {
     return `import { Datalyr } from '${importPath}';
 
+// IMPORTANT: Set DATALYR_API_KEY in your environment
+// For Expo: Add to app.config.js extra field and use expo-constants
+// For bare RN: Use react-native-config or babel-plugin-transform-inline-environment-variables
+const DATALYR_API_KEY = process.env.DATALYR_API_KEY;
+
 let initialized = false;
 
 export async function initDatalyr(): Promise<void> {
   if (initialized) return;
 
+  if (!DATALYR_API_KEY) {
+    console.warn('Datalyr: API key not configured. Set DATALYR_API_KEY environment variable.');
+    return;
+  }
+
   await Datalyr.initialize({
-    apiKey: '${apiKey}',
+    apiKey: DATALYR_API_KEY,
     enableAutoEvents: true,
     enableAttribution: true,
     debug: __DEV__,
@@ -500,13 +512,23 @@ export function identifyUser(userId: string, traits?: Record<string, unknown>):
   }
   return `import { Datalyr } from '${importPath}';
 
+// IMPORTANT: Set DATALYR_API_KEY in your environment
+// For Expo: Add to app.config.js extra field and use expo-constants
+// For bare RN: Use react-native-config or babel-plugin-transform-inline-environment-variables
+const DATALYR_API_KEY = process.env.DATALYR_API_KEY;
+
 let initialized = false;
 
 export async function initDatalyr() {
   if (initialized) return;
 
+  if (!DATALYR_API_KEY) {
+    console.warn('Datalyr: API key not configured. Set DATALYR_API_KEY environment variable.');
+    return;
+  }
+
   await Datalyr.initialize({
-    apiKey: '${apiKey}',
+    apiKey: DATALYR_API_KEY,
     enableAutoEvents: true,
     enableAttribution: true,
     debug: __DEV__,
@@ -537,22 +559,22 @@ import path4 from "path";
 import ora from "ora";
 import chalk from "chalk";
 var currentSpinner = null;
-function startSpinner(text) {
+function startSpinner(text2) {
   if (currentSpinner) {
     currentSpinner.stop();
   }
-  currentSpinner = ora({ text, color: "cyan" }).start();
+  currentSpinner = ora({ text: text2, color: "cyan" }).start();
   return currentSpinner;
 }
-function succeedSpinner(text) {
+function succeedSpinner(text2) {
   if (currentSpinner) {
-    currentSpinner.succeed(text);
+    currentSpinner.succeed(text2);
     currentSpinner = null;
   }
 }
-function failSpinner(text) {
+function failSpinner(text2) {
   if (currentSpinner) {
-    currentSpinner.fail(text);
+    currentSpinner.fail(text2);
     currentSpinner = null;
   }
 }
@@ -652,7 +674,7 @@ async function updateEnvFile(cwd, envVars, options = {}) {
   if (options.dryRun) {
     return true;
   }
-  const spinner = startSpinner(`Updating ${envFileName}...`);
+  const spinner2 = startSpinner(`Updating ${envFileName}...`);
   try {
     let existingContent = "";
     if (await fileExists(envPath)) {
@@ -715,9 +737,27 @@ function parseEnvFile(content) {
 }
 function getEnvVarsForFramework(framework, apiKey) {
   const vars = [];
+  const getPublicEnvVarKey = (fw) => {
+    switch (fw) {
+      case "react":
+      case "react-vite":
+        return "VITE_DATALYR_WORKSPACE_ID";
+      case "svelte":
+      case "sveltekit":
+        return "PUBLIC_DATALYR_WORKSPACE_ID";
+      case "vue":
+      case "nuxt":
+        return "NUXT_PUBLIC_DATALYR_WORKSPACE_ID";
+      case "remix":
+      case "astro":
+      case "nextjs":
+      default:
+        return "NEXT_PUBLIC_DATALYR_WORKSPACE_ID";
+    }
+  };
   if (["nextjs", "react", "react-vite", "svelte", "sveltekit", "vue", "nuxt", "remix", "astro"].includes(framework)) {
     vars.push({
-      key: "NEXT_PUBLIC_DATALYR_WORKSPACE_ID",
+      key: getPublicEnvVarKey(framework),
       value: "",
       description: "Your Datalyr workspace ID (get from dashboard)",
       isPublic: true
@@ -753,7 +793,7 @@ function generateFilesForFramework(context, apiKey) {
     case "nextjs":
       return generateNextJSFiles({
         language,
-        hasAppRouter: context.entryPoints.some((p) => p.includes("app/layout")),
+        hasAppRouter: context.entryPoints.some((p2) => p2.includes("app/layout")),
         apiKey
       });
     case "react":
@@ -766,8 +806,7 @@ function generateFilesForFramework(context, apiKey) {
     case "expo":
       return generateReactNativeFiles({
         language,
-        isExpo: framework === "expo",
-        apiKey
+        isExpo: framework === "expo"
       });
     case "sveltekit":
       return generateSvelteKitFiles(language, apiKey);
@@ -1017,7 +1056,7 @@ async function installPackages(cwd, packages, options = {}) {
   if (options.dryRun) return true;
   const pm = await detectPackageManager(cwd);
   const command = getInstallCommand(pm, packages, options.dev);
-  const spinner = startSpinner(`Installing ${packages.join(", ")}...`);
+  const spinner2 = startSpinner(`Installing ${packages.join(", ")}...`);
   try {
     const [cmd, ...args] = command.split(" ");
     await execa(cmd, args, { cwd, stdio: "pipe" });
@@ -1113,6 +1152,2336 @@ var logger = {
   blank: () => console.log()
 };
 
+// src/agent/runner.ts
+import * as p from "@clack/prompts";
+import chalk4 from "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
+  /\$\w/,
+  // Variable expansion (could contain malicious code)
+  /\|\s*sh/,
+  // Piping to shell
+  /\|\s*bash/,
+  // Piping to bash
+  /\|\s*zsh/,
+  // Piping to zsh
+  /\|\|/,
+  // Or operator (allows fallback commands)
+  /\s&\s/,
+  // Background execution mid-command
+  /\s&$/,
+  // Background execution at end
+  /rm\s+-rf/,
+  // Dangerous rm
+  /rm\s+-r/,
+  // Recursive rm
+  />\s*\//,
+  // Overwriting system files
+  /&&\s*rm/,
+  // rm after &&
+  /\|\s*rm/
+  // rm after pipe
+];
+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/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
+import { writeFile as writeFile2, readFile as readFile2, mkdir } from "fs/promises";
+import { join, dirname, resolve } from "path";
+import { existsSync } from "fs";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { glob as glob2 } from "glob";
+var execAsync = promisify(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(chalk4.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 ${chalk4.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: ${chalk4.cyan(workspace.name)}`);
+      } else {
+        workspace = defaultWorkspace;
+        validateSpinner.stop(`Workspace: ${chalk4.cyan(workspace.name)}`);
+      }
+    } catch (error) {
+      validateSpinner.stop(chalk4.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 ${chalk4.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: ${chalk4.cyan(signupUrl)}`);
+          }
+        }
+      }
+    }
+  }
+  if (!workspace || !apiKey) {
+    p.log.error(`Failed to validate API key after ${maxAttempts} attempts.`);
+    p.log.info(`Get help at ${chalk4.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: ${chalk4.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:
+  ${chalk4.green("\u2022")} Add/remove Meta, Google, TikTok pixels without code
+  ${chalk4.green("\u2022")} Auto-fire datalyr.track() events to all pixels
+  ${chalk4.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(
+    `${chalk4.bold("Auto-tracked (no code needed):")}
+` + autoTrackedEvents.map((e) => `  ${chalk4.dim("\u2022")} ${e}`).join("\n") + `
+
+${chalk4.bold("High-value events")} are the key actions that matter for your business:
+  ${chalk4.dim("\u2022")} Conversions (signups, purchases, leads)
+  ${chalk4.dim("\u2022")} Engagement (feature usage, key interactions)
+  ${chalk4.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 ${chalk4.cyan(businessTypeLabel)} app, we suggest these events:
+
+` + uniqueEvents.filter((e) => e.priority === "high").map((e) => `  ${chalk4.green("\u2022")} ${chalk4.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) => `  ${chalk4.green("\u2022")} ${chalk4.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:
+${chalk4.green("\u2022")} Install ${chalk4.cyan(allSdks.join(", "))}
+${chalk4.green("\u2022")} Create initialization code
+${chalk4.green("\u2022")} Configure environment variables
+${chalk4.green("\u2022")} Set up workspace: ${chalk4.cyan(workspace.name)}
+${adPlatforms.length > 0 ? `${chalk4.green("\u2022")} Configure attribution for: ${chalk4.cyan(adPlatforms.join(", "))}` : ""}
+${containerEnabled && platformType !== "mobile" ? `${chalk4.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(chalk4.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: ${chalk4.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 writeFile2(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 ? `
+
+${chalk4.bold("Next steps:")}
+${platformSteps.map((s) => `  ${chalk4.yellow("\u2192")} ${s}`).join("\n")}` : "";
+      p.note(
+        `Your workspace "${workspace.name}" is ready!
+
+${chalk4.bold("Start tracking events:")}
+  ${eventExamples || "datalyr.track('event_name', { property: 'value' })"}
+
+${chalk4.bold("View your data:")}
+  ${chalk4.cyan(`https://app.datalyr.com/dashboard/${workspace.id}/events`)}${stepsText}`,
+        "Success!"
+      );
+      p.outro(chalk4.green("Datalyr is ready to use!"));
+    } else {
+      agentSpinner.stop(chalk4.red("Installation failed"));
+      p.log.error(result.error || "Unknown error");
+    }
+    return result;
+  } catch (error) {
+    agentSpinner.stop(chalk4.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 input2 = taskComplete.input;
+          return {
+            success: input2.success,
+            message: input2.summary,
+            filesModified: input2.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 input2 = toolUse.input;
+            return {
+              success: input2.success,
+              message: input2.summary,
+              filesModified: input2.files_modified || filesModified
+            };
+          }
+          const result = await executeTool(toolUse, cwd, debug);
+          if (toolUse.name === "write_file" && !result.is_error) {
+            const path6 = toolUse.input.path;
+            if (!filesModified.includes(path6)) {
+              filesModified.push(path6);
+            }
+          }
+          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 = resolve(basePath);
+  const resolvedTarget = resolve(basePath, targetPath);
+  return resolvedTarget.startsWith(resolvedBase + "/") || resolvedTarget === resolvedBase;
+}
+async function executeTool(toolUse, cwd, debug) {
+  const { name, input: input2 } = toolUse;
+  if (debug) {
+    console.log(`[DEBUG] Executing tool: ${name}`, input2);
+  }
+  try {
+    switch (name) {
+      case "read_file": {
+        if (typeof input2.path !== "string" || !input2.path.trim()) {
+          return { content: "Error: path must be a non-empty string", is_error: true };
+        }
+        const path6 = input2.path.trim();
+        if (!isPathSafe(cwd, path6)) {
+          return { content: "Error: path traversal detected - access denied", is_error: true };
+        }
+        const fullPath = join(cwd, path6);
+        const content = await readFile2(fullPath, "utf-8");
+        return { content };
+      }
+      case "write_file": {
+        if (typeof input2.path !== "string" || !input2.path.trim()) {
+          return { content: "Error: path must be a non-empty string", is_error: true };
+        }
+        if (typeof input2.content !== "string") {
+          return { content: "Error: content must be a string", is_error: true };
+        }
+        const path6 = input2.path.trim();
+        const content = input2.content;
+        if (!isPathSafe(cwd, path6)) {
+          return { content: "Error: path traversal detected - access denied", is_error: true };
+        }
+        const fullPath = join(cwd, path6);
+        const dir = dirname(fullPath);
+        if (!existsSync(dir)) {
+          await mkdir(dir, { recursive: true });
+        }
+        await writeFile2(fullPath, content, "utf-8");
+        return { content: `Successfully wrote ${path6}` };
+      }
+      case "run_command": {
+        if (typeof input2.command !== "string" || !input2.command.trim()) {
+          return { content: "Error: command must be a non-empty string", is_error: true };
+        }
+        const command = input2.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 input2.path !== "string") {
+          return { content: "Error: path must be a string", is_error: true };
+        }
+        const path6 = input2.path.trim() || ".";
+        const pattern = typeof input2.pattern === "string" ? input2.pattern : "*";
+        if (!isPathSafe(cwd, path6)) {
+          return { content: "Error: path traversal detected - access denied", is_error: true };
+        }
+        const fullPath = join(cwd, path6);
+        const files = await glob2(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 };
+  }
+}
+
 // src/index.ts
 async function runWizard(options = {}) {
   const cwd = options.cwd || process.cwd();
@@ -1130,9 +3499,9 @@ async function runWizard(options = {}) {
     if (!options.json) {
       logger.step(2, 5, "Analyzing your project...");
     }
-    const spinner = options.json ? null : startSpinner("Scanning project structure...");
+    const spinner2 = options.json ? null : startSpinner("Scanning project structure...");
     let detection = await detectFramework(cwd);
-    if (spinner) {
+    if (spinner2) {
       succeedSpinner(`Detected ${getFrameworkDisplayName(detection.framework)}`);
     }
     if (detection.framework === "unknown" || options.framework) {
@@ -1270,6 +3639,7 @@ async function findEntryPoints(cwd, framework) {
 export {
   detectFramework,
   generateInstallationPlan,
+  runAgentWizard,
   runWizard
 };
 //# sourceMappingURL=index.mjs.map