@datalyr/wizard 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1275 @@
+// src/index.ts
+import path5 from "path";
+
+// src/detection/detector.ts
+import path2 from "path";
+
+// src/utils/fs.ts
+import fs from "fs-extra";
+import path from "path";
+import { glob } from "glob";
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFile(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readJson(filePath) {
+  try {
+    return await fs.readJson(filePath);
+  } catch {
+    return null;
+  }
+}
+async function readPackageJson(cwd) {
+  return readJson(path.join(cwd, "package.json"));
+}
+async function findFile(cwd, patterns) {
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, { cwd, nodir: true });
+    if (matches.length > 0) {
+      return path.join(cwd, matches[0]);
+    }
+  }
+  return null;
+}
+async function findFiles(cwd, pattern) {
+  const matches = await glob(pattern, {
+    cwd,
+    ignore: ["node_modules/**", ".git/**"]
+  });
+  return matches.map((f) => path.join(cwd, f));
+}
+
+// src/detection/detector.ts
+async function detectFramework(cwd) {
+  const signals = [];
+  const pkg = await readPackageJson(cwd);
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  if (await fileExists(path2.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(path2.join(cwd, "app", "layout.tsx")) || await fileExists(path2.join(cwd, "app", "layout.js"))) {
+      signals.push({ framework: "nextjs", score: 20, signal: "App Router detected" });
+    }
+    if (await fileExists(path2.join(cwd, "pages", "_app.tsx")) || await fileExists(path2.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/utils/package-manager.ts
+import path3 from "path";
+async function detectPackageManager(cwd) {
+  if (await fileExists(path3.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (await fileExists(path3.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fileExists(path3.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fileExists(path3.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  return "npm";
+}
+function getInstallCommand(pm, packages, dev = false) {
+  const pkgList = packages.join(" ");
+  switch (pm) {
+    case "npm":
+      return dev ? `npm install -D ${pkgList}` : `npm install ${pkgList}`;
+    case "yarn":
+      return dev ? `yarn add -D ${pkgList}` : `yarn add ${pkgList}`;
+    case "pnpm":
+      return dev ? `pnpm add -D ${pkgList}` : `pnpm add ${pkgList}`;
+    case "bun":
+      return dev ? `bun add -d ${pkgList}` : `bun add ${pkgList}`;
+  }
+}
+
+// src/generators/templates/nextjs.ts
+function generateNextJSFiles(options) {
+  const { language, hasAppRouter } = options;
+  const ext = language === "typescript" ? "tsx" : "jsx";
+  const tsExt = language === "typescript" ? "ts" : "js";
+  const files = [];
+  if (hasAppRouter) {
+    files.push({
+      path: `app/providers.${ext}`,
+      action: "create",
+      description: "Datalyr provider component",
+      content: generateAppRouterProvider(language)
+    });
+    files.push({
+      path: `lib/datalyr.${tsExt}`,
+      action: "create",
+      description: "Server-side Datalyr instance",
+      content: generateServerInstance(language)
+    });
+  } else {
+    files.push({
+      path: `lib/datalyr.${tsExt}`,
+      action: "create",
+      description: "Datalyr initialization",
+      content: generatePagesRouterInit(language)
+    });
+    files.push({
+      path: `lib/datalyr-server.${tsExt}`,
+      action: "create",
+      description: "Server-side Datalyr instance",
+      content: generateServerInstance(language)
+    });
+  }
+  return files;
+}
+function generateAppRouterProvider(language) {
+  if (language === "typescript") {
+    return `'use client';
+
+import datalyr from '@datalyr/web';
+import { useEffect } from 'react';
+
+interface DatalyrProviderProps {
+  children: React.ReactNode;
+}
+
+export function DatalyrProvider({ children }: DatalyrProviderProps) {
+  useEffect(() => {
+    datalyr.init({
+      workspaceId: process.env.NEXT_PUBLIC_DATALYR_WORKSPACE_ID!,
+      debug: process.env.NODE_ENV === 'development',
+      trackSPA: true,
+    });
+  }, []);
+
+  return <>{children}</>;
+}
+`;
+  }
+  return `'use client';
+
+import datalyr from '@datalyr/web';
+import { useEffect } from 'react';
+
+export function DatalyrProvider({ children }) {
+  useEffect(() => {
+    datalyr.init({
+      workspaceId: process.env.NEXT_PUBLIC_DATALYR_WORKSPACE_ID,
+      debug: process.env.NODE_ENV === 'development',
+      trackSPA: true,
+    });
+  }, []);
+
+  return <>{children}</>;
+}
+`;
+}
+function generateServerInstance(language) {
+  if (language === "typescript") {
+    return `import Datalyr from '@datalyr/api';
+
+// Server-side Datalyr instance
+export const datalyr = new Datalyr(process.env.DATALYR_API_KEY!);
+
+// Helper to track server-side events
+export async function trackServerEvent(
+  event: string,
+  properties?: Record<string, unknown>,
+  userId?: string,
+) {
+  await datalyr.track({
+    event,
+    properties,
+    userId,
+    timestamp: new Date().toISOString(),
+  });
+}
+`;
+  }
+  return `import Datalyr from '@datalyr/api';
+
+// Server-side Datalyr instance
+export const datalyr = new Datalyr(process.env.DATALYR_API_KEY);
+
+// Helper to track server-side events
+export async function trackServerEvent(event, properties, userId) {
+  await datalyr.track({
+    event,
+    properties,
+    userId,
+    timestamp: new Date().toISOString(),
+  });
+}
+`;
+}
+function generatePagesRouterInit(language) {
+  if (language === "typescript") {
+    return `import datalyr from '@datalyr/web';
+
+let initialized = false;
+
+export function initDatalyr(): void {
+  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 };
+`;
+  }
+  return `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 };
+`;
+}
+
+// src/generators/templates/react.ts
+function generateReactFiles(options) {
+  const { language, isVite } = options;
+  const ext = language === "typescript" ? "ts" : "js";
+  return [
+    {
+      path: `src/lib/datalyr.${ext}`,
+      action: "create",
+      description: "Datalyr initialization",
+      content: generateReactInit(language)
+    }
+  ];
+}
+function generateReactInit(language) {
+  if (language === "typescript") {
+    return `import datalyr from '@datalyr/web';
+
+let initialized = false;
+
+export function initDatalyr(): void {
+  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;
+}
+
+// Re-export for convenience
+export { datalyr };
+
+// Usage in your main.tsx/App.tsx:
+// import { initDatalyr } from './lib/datalyr';
+// initDatalyr();
+`;
+  }
+  return `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;
+}
+
+// Re-export for convenience
+export { datalyr };
+
+// Usage in your main.jsx/App.jsx:
+// import { initDatalyr } from './lib/datalyr';
+// initDatalyr();
+`;
+}
+
+// src/generators/templates/react-native.ts
+function generateReactNativeFiles(options) {
+  const { language, isExpo, apiKey } = options;
+  const ext = language === "typescript" ? "ts" : "js";
+  return [
+    {
+      path: `src/utils/datalyr.${ext}`,
+      action: "create",
+      description: "Datalyr initialization",
+      content: generateReactNativeInit(language, isExpo, apiKey)
+    }
+  ];
+}
+function generateReactNativeInit(language, isExpo, apiKey) {
+  const importPath = isExpo ? "@datalyr/react-native/expo" : "@datalyr/react-native";
+  if (language === "typescript") {
+    return `import { Datalyr } from '${importPath}';
+
+let initialized = false;
+
+export async function initDatalyr(): Promise<void> {
+  if (initialized) return;
+
+  await Datalyr.initialize({
+    apiKey: '${apiKey}',
+    enableAutoEvents: true,
+    enableAttribution: true,
+    debug: __DEV__,
+  });
+
+  initialized = true;
+}
+
+// Re-export for convenience
+export { Datalyr };
+
+// Track custom events
+export function trackEvent(event: string, properties?: Record<string, unknown>): void {
+  Datalyr.track(event, properties);
+}
+
+// Identify users
+export function identifyUser(userId: string, traits?: Record<string, unknown>): void {
+  Datalyr.identify(userId, traits);
+}
+`;
+  }
+  return `import { Datalyr } from '${importPath}';
+
+let initialized = false;
+
+export async function initDatalyr() {
+  if (initialized) return;
+
+  await Datalyr.initialize({
+    apiKey: '${apiKey}',
+    enableAutoEvents: true,
+    enableAttribution: true,
+    debug: __DEV__,
+  });
+
+  initialized = true;
+}
+
+// Re-export for convenience
+export { Datalyr };
+
+// Track custom events
+export function trackEvent(event, properties) {
+  Datalyr.track(event, properties);
+}
+
+// Identify users
+export function identifyUser(userId, traits) {
+  Datalyr.identify(userId, traits);
+}
+`;
+}
+
+// src/installers/env.ts
+import path4 from "path";
+
+// src/cli/ui.ts
+import ora from "ora";
+import chalk from "chalk";
+var currentSpinner = null;
+function startSpinner(text) {
+  if (currentSpinner) {
+    currentSpinner.stop();
+  }
+  currentSpinner = ora({ text, color: "cyan" }).start();
+  return currentSpinner;
+}
+function succeedSpinner(text) {
+  if (currentSpinner) {
+    currentSpinner.succeed(text);
+    currentSpinner = null;
+  }
+}
+function failSpinner(text) {
+  if (currentSpinner) {
+    currentSpinner.fail(text);
+    currentSpinner = null;
+  }
+}
+function stopSpinner() {
+  if (currentSpinner) {
+    currentSpinner.stop();
+    currentSpinner = null;
+  }
+}
+function printWelcome() {
+  console.log();
+  console.log(chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  console.log(chalk.cyan("\u2551") + chalk.bold("          Welcome to Datalyr Wizard!           ") + chalk.cyan("\u2551"));
+  console.log(chalk.cyan("\u2551") + "    AI-powered SDK installation for Datalyr    " + chalk.cyan("\u2551"));
+  console.log(chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  console.log();
+}
+function printSuccess() {
+  console.log();
+  console.log(chalk.green.bold("Installation complete!"));
+  console.log();
+  console.log(chalk.bold("Next steps:"));
+  console.log();
+  console.log("  1. Add your workspace ID to .env.local:");
+  console.log(chalk.cyan("     NEXT_PUBLIC_DATALYR_WORKSPACE_ID=your_workspace_id"));
+  console.log();
+  console.log("  2. Start tracking events:");
+  console.log(chalk.cyan("     datalyr.track('button_clicked', { button: 'signup' })"));
+  console.log();
+  console.log("  3. View your data:");
+  console.log(chalk.cyan("     https://app.datalyr.com/dashboard"));
+  console.log();
+  console.log(chalk.gray("Documentation: https://docs.datalyr.com"));
+  console.log(chalk.gray("Support: hello@datalyr.com"));
+  console.log();
+}
+function printPlan(plan) {
+  console.log();
+  console.log(chalk.bold("Installation Plan:"));
+  console.log();
+  if (plan.packages.length > 0) {
+    console.log(chalk.cyan("  \u{1F4E6} Packages:"));
+    plan.packages.forEach((pkg) => {
+      console.log(`     \u2022 ${pkg}`);
+    });
+    console.log();
+  }
+  if (plan.files.length > 0) {
+    console.log(chalk.cyan("  \u{1F4DD} Files to create/update:"));
+    plan.files.forEach((file) => {
+      const actionIcon = file.action === "create" ? chalk.green("(create)") : chalk.yellow("(update)");
+      console.log(`     \u2022 ${file.path} ${actionIcon}`);
+    });
+    console.log();
+  }
+}
+function printDetection(result) {
+  console.log();
+  console.log(chalk.bold("Detected Configuration:"));
+  console.log(`  Framework: ${chalk.cyan(result.framework)}`);
+  console.log(`  Language:  ${chalk.cyan(result.language)}`);
+  console.log(`  SDK Needs: ${chalk.cyan(result.sdks.join(" + "))}`);
+  console.log();
+}
+function printError(message, details) {
+  console.log();
+  console.log(chalk.red.bold("Error:"), message);
+  if (details) {
+    console.log(chalk.gray(details));
+  }
+  console.log();
+}
+function printDryRun(plan) {
+  console.log();
+  console.log(chalk.yellow.bold("[DRY RUN] No changes will be made"));
+  console.log();
+  if (plan.commands.length > 0) {
+    console.log(chalk.bold("Would run:"));
+    plan.commands.forEach((cmd) => console.log(chalk.cyan(`  $ ${cmd}`)));
+    console.log();
+  }
+  if (plan.files.length > 0) {
+    console.log(chalk.bold("Would create/update files:"));
+    plan.files.forEach((file) => {
+      console.log(chalk.cyan(`  ${file.path} (${file.action})`));
+    });
+    console.log();
+  }
+}
+
+// src/installers/env.ts
+async function updateEnvFile(cwd, envVars, options = {}) {
+  if (envVars.length === 0) return true;
+  const envFileName = options.envFile || ".env.local";
+  const envPath = path4.join(cwd, envFileName);
+  const examplePath = path4.join(cwd, ".env.example");
+  if (options.dryRun) {
+    return true;
+  }
+  const spinner = startSpinner(`Updating ${envFileName}...`);
+  try {
+    let existingContent = "";
+    if (await fileExists(envPath)) {
+      existingContent = await readFile(envPath) || "";
+    }
+    const existingVars = parseEnvFile(existingContent);
+    const lines = [];
+    if (existingContent) {
+      lines.push(existingContent.trim());
+      lines.push("");
+    }
+    const newVars = envVars.filter((v) => !existingVars.has(v.key));
+    if (newVars.length > 0) {
+      lines.push("# Datalyr Analytics");
+      for (const envVar of newVars) {
+        if (envVar.description) {
+          lines.push(`# ${envVar.description}`);
+        }
+        lines.push(`${envVar.key}=${envVar.value}`);
+      }
+    }
+    await writeFile(envPath, lines.join("\n") + "\n");
+    if (await fileExists(examplePath)) {
+      await updateEnvExample(examplePath, envVars);
+    }
+    succeedSpinner(`Updated ${envFileName}`);
+    return true;
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+}
+async function updateEnvExample(examplePath, envVars) {
+  let content = await readFile(examplePath) || "";
+  const existingVars = parseEnvFile(content);
+  const newVars = envVars.filter((v) => !existingVars.has(v.key));
+  if (newVars.length === 0) return;
+  const lines = content.trim().split("\n");
+  lines.push("");
+  lines.push("# Datalyr Analytics");
+  for (const envVar of newVars) {
+    const exampleValue = envVar.isPublic ? "your_workspace_id" : "dk_your_api_key";
+    lines.push(`${envVar.key}=${exampleValue}`);
+  }
+  await writeFile(examplePath, lines.join("\n") + "\n");
+}
+function parseEnvFile(content) {
+  const vars = /* @__PURE__ */ new Set();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=/);
+      if (match) {
+        vars.add(match[1]);
+      }
+    }
+  }
+  return vars;
+}
+function getEnvVarsForFramework(framework, apiKey) {
+  const vars = [];
+  if (["nextjs", "react", "react-vite", "svelte", "sveltekit", "vue", "nuxt", "remix", "astro"].includes(framework)) {
+    vars.push({
+      key: "NEXT_PUBLIC_DATALYR_WORKSPACE_ID",
+      value: "",
+      description: "Your Datalyr workspace ID (get from dashboard)",
+      isPublic: true
+    });
+  }
+  if (["nextjs", "sveltekit", "nuxt", "remix", "astro", "node"].includes(framework)) {
+    vars.push({
+      key: "DATALYR_API_KEY",
+      value: apiKey,
+      description: "Datalyr API key for server-side tracking",
+      isPublic: false
+    });
+  }
+  return vars;
+}
+
+// src/generators/index.ts
+function generateInstallationPlan(context, apiKey) {
+  const packages = context.sdks.filter((sdk) => sdk !== "DatalyrSDK");
+  const files = generateFilesForFramework(context, apiKey);
+  const envVars = getEnvVarsForFramework(context.framework, apiKey);
+  const postInstallSteps = getPostInstallSteps(context);
+  return {
+    packages,
+    files,
+    envVars,
+    postInstallSteps
+  };
+}
+function generateFilesForFramework(context, apiKey) {
+  const { framework, language } = context;
+  switch (framework) {
+    case "nextjs":
+      return generateNextJSFiles({
+        language,
+        hasAppRouter: context.entryPoints.some((p) => p.includes("app/layout")),
+        apiKey
+      });
+    case "react":
+    case "react-vite":
+      return generateReactFiles({
+        language,
+        isVite: framework === "react-vite"
+      });
+    case "react-native":
+    case "expo":
+      return generateReactNativeFiles({
+        language,
+        isExpo: framework === "expo",
+        apiKey
+      });
+    case "sveltekit":
+      return generateSvelteKitFiles(language, apiKey);
+    case "svelte":
+      return generateSvelteFiles(language);
+    case "node":
+      return generateNodeFiles(language, apiKey);
+    case "ios":
+      return generateIOSFiles(apiKey);
+    default:
+      return generateGenericWebFiles(language);
+  }
+}
+function generateSvelteKitFiles(language, apiKey) {
+  const ext = language === "typescript" ? "ts" : "js";
+  return [
+    {
+      path: `src/lib/datalyr.${ext}`,
+      action: "create",
+      description: "Client-side Datalyr initialization",
+      content: `import datalyr from '@datalyr/web';
+import { browser } from '$app/environment';
+
+let initialized = false;
+
+export function initDatalyr()${language === "typescript" ? ": void" : ""} {
+  if (initialized || !browser) return;
+
+  datalyr.init({
+    workspaceId: import.meta.env.VITE_DATALYR_WORKSPACE_ID,
+    debug: import.meta.env.DEV,
+    trackSPA: true,
+  });
+
+  initialized = true;
+}
+
+export { datalyr };
+`
+    },
+    {
+      path: `src/lib/datalyr.server.${ext}`,
+      action: "create",
+      description: "Server-side Datalyr instance",
+      content: `import Datalyr from '@datalyr/api';
+import { DATALYR_API_KEY } from '$env/static/private';
+
+export const datalyr = new Datalyr(DATALYR_API_KEY);
+`
+    }
+  ];
+}
+function generateSvelteFiles(language) {
+  const ext = language === "typescript" ? "ts" : "js";
+  return [
+    {
+      path: `src/lib/datalyr.${ext}`,
+      action: "create",
+      description: "Datalyr initialization",
+      content: `import datalyr from '@datalyr/web';
+
+let initialized = false;
+
+export function initDatalyr()${language === "typescript" ? ": void" : ""} {
+  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 };
+`
+    }
+  ];
+}
+function generateNodeFiles(language, apiKey) {
+  const ext = language === "typescript" ? "ts" : "js";
+  return [
+    {
+      path: `src/lib/datalyr.${ext}`,
+      action: "create",
+      description: "Datalyr server instance",
+      content: language === "typescript" ? `import Datalyr from '@datalyr/api';
+
+const apiKey = process.env.DATALYR_API_KEY;
+if (!apiKey) {
+  throw new Error('DATALYR_API_KEY environment variable is required');
+}
+
+export const datalyr = new Datalyr(apiKey);
+
+export async function trackEvent(
+  event: string,
+  properties?: Record<string, unknown>,
+  userId?: string,
+): Promise<void> {
+  await datalyr.track({
+    event,
+    properties,
+    userId,
+    timestamp: new Date().toISOString(),
+  });
+}
+` : `import Datalyr from '@datalyr/api';
+
+const apiKey = process.env.DATALYR_API_KEY;
+if (!apiKey) {
+  throw new Error('DATALYR_API_KEY environment variable is required');
+}
+
+export const datalyr = new Datalyr(apiKey);
+
+export async function trackEvent(event, properties, userId) {
+  await datalyr.track({
+    event,
+    properties,
+    userId,
+    timestamp: new Date().toISOString(),
+  });
+}
+`
+    }
+  ];
+}
+function generateIOSFiles(_apiKey) {
+  return [
+    {
+      path: "DatalyrConfig.swift",
+      action: "create",
+      description: "Datalyr iOS configuration",
+      content: `import DatalyrSDK
+import Foundation
+
+struct DatalyrConfig {
+    /// Initialize Datalyr SDK
+    /// Reads configuration from Info.plist for security
+    static func initialize() {
+        guard let apiKey = Bundle.main.object(forInfoDictionaryKey: "DATALYR_API_KEY") as? String,
+              let workspaceId = Bundle.main.object(forInfoDictionaryKey: "DATALYR_WORKSPACE_ID") as? String else {
+            #if DEBUG
+            fatalError("Datalyr API key or workspace ID not found in Info.plist. Add DATALYR_API_KEY and DATALYR_WORKSPACE_ID to your Info.plist.")
+            #else
+            print("[Datalyr] Warning: API key or workspace ID not configured")
+            return
+            #endif
+        }
+
+        Datalyr.shared.configure(
+            apiKey: apiKey,
+            workspaceId: workspaceId,
+            options: DatalyrOptions(
+                debug: false, // Set to true during development
+                enableAutoEvents: true,
+                enableAttribution: true
+            )
+        )
+    }
+}
+
+// SETUP INSTRUCTIONS:
+// 1. Add to Info.plist:
+//    <key>DATALYR_API_KEY</key>
+//    <string>$(DATALYR_API_KEY)</string>
+//    <key>DATALYR_WORKSPACE_ID</key>
+//    <string>$(DATALYR_WORKSPACE_ID)</string>
+//
+// 2. Add to your .xcconfig file (recommended) or scheme environment:
+//    DATALYR_API_KEY = dk_your_api_key_here
+//    DATALYR_WORKSPACE_ID = your_workspace_id_here
+//
+// 3. Call DatalyrConfig.initialize() in your App's init or AppDelegate
+`
+    },
+    {
+      path: "Datalyr.xcconfig",
+      action: "create",
+      description: "Datalyr configuration file (add your API key here)",
+      content: `// Datalyr Configuration
+// Do NOT commit this file with real credentials to version control
+// Add to .gitignore: *.xcconfig
+
+DATALYR_API_KEY = YOUR_API_KEY_HERE
+DATALYR_WORKSPACE_ID = YOUR_WORKSPACE_ID_HERE
+`
+    }
+  ];
+}
+function generateGenericWebFiles(language) {
+  const ext = language === "typescript" ? "ts" : "js";
+  return [
+    {
+      path: `src/lib/datalyr.${ext}`,
+      action: "create",
+      description: "Datalyr initialization",
+      content: `import datalyr from '@datalyr/web';
+
+export function initDatalyr()${language === "typescript" ? ": void" : ""} {
+  datalyr.init({
+    workspaceId: 'YOUR_WORKSPACE_ID',
+    debug: true,
+  });
+}
+
+export { datalyr };
+`
+    }
+  ];
+}
+function getPostInstallSteps(context) {
+  const steps = [];
+  switch (context.framework) {
+    case "nextjs":
+      steps.push("Add your workspace ID to .env.local");
+      steps.push("Import DatalyrProvider in your app/layout.tsx");
+      break;
+    case "react":
+    case "react-vite":
+      steps.push("Add VITE_DATALYR_WORKSPACE_ID to your .env file");
+      steps.push("Call initDatalyr() in your main.tsx");
+      break;
+    case "react-native":
+    case "expo":
+      steps.push("Run: cd ios && pod install");
+      steps.push("Call initDatalyr() in your App.tsx useEffect");
+      break;
+    case "ios":
+      steps.push("Add DatalyrSDK via Swift Package Manager");
+      steps.push("Add DATALYR_API_KEY and DATALYR_WORKSPACE_ID to Datalyr.xcconfig");
+      steps.push("Configure Info.plist to use the xcconfig variables");
+      steps.push("Call DatalyrConfig.initialize() in your App");
+      break;
+    default:
+      steps.push("Add your workspace ID to your environment");
+  }
+  return steps;
+}
+
+// src/installers/npm.ts
+import { execa } from "execa";
+async function installPackages(cwd, packages, options = {}) {
+  if (packages.length === 0) return true;
+  if (options.dryRun) return true;
+  const pm = await detectPackageManager(cwd);
+  const command = getInstallCommand(pm, packages, options.dev);
+  const spinner = startSpinner(`Installing ${packages.join(", ")}...`);
+  try {
+    const [cmd, ...args] = command.split(" ");
+    await execa(cmd, args, { cwd, stdio: "pipe" });
+    succeedSpinner(`Installed ${packages.join(", ")}`);
+    return true;
+  } catch (error) {
+    failSpinner(`Failed to install packages`);
+    console.error(error instanceof Error ? error.message : error);
+    return false;
+  }
+}
+
+// src/cli/prompts.ts
+import { input, confirm, select } from "@inquirer/prompts";
+import chalk2 from "chalk";
+async function promptApiKey(existingKey) {
+  if (existingKey) {
+    return existingKey;
+  }
+  const apiKey = await input({
+    message: "Enter your Datalyr API key (starts with dk_):",
+    validate: (value) => {
+      if (!value.startsWith("dk_")) {
+        return 'API key must start with "dk_"';
+      }
+      if (value.length < 10) {
+        return "API key seems too short";
+      }
+      return true;
+    }
+  });
+  return apiKey;
+}
+async function promptFramework() {
+  return select({
+    message: "Select your framework:",
+    choices: [
+      { name: "Next.js", value: "nextjs" },
+      { name: "React (Vite)", value: "react-vite" },
+      { name: "React (Create React App)", value: "react" },
+      { name: "Svelte/SvelteKit", value: "sveltekit" },
+      { name: "Vue/Nuxt", value: "nuxt" },
+      { name: "Remix", value: "remix" },
+      { name: "Astro", value: "astro" },
+      { name: "React Native", value: "react-native" },
+      { name: "Expo", value: "expo" },
+      { name: "iOS (Swift)", value: "ios" },
+      { name: "Node.js (Server only)", value: "node" }
+    ]
+  });
+}
+async function promptProceed() {
+  return confirm({
+    message: "Proceed with installation?",
+    default: true
+  });
+}
+
+// src/utils/logger.ts
+import chalk3 from "chalk";
+var logger = {
+  info: (message) => console.log(chalk3.blue("\u2139"), message),
+  success: (message) => console.log(chalk3.green("\u2713"), message),
+  warn: (message) => console.log(chalk3.yellow("\u26A0"), message),
+  error: (message) => console.log(chalk3.red("\u2717"), message),
+  debug: (message, enabled = false) => {
+    if (enabled) console.log(chalk3.gray("[debug]"), message);
+  },
+  header: (title) => {
+    console.log();
+    console.log(chalk3.bold.cyan(title));
+    console.log(chalk3.gray("\u2500".repeat(40)));
+  },
+  step: (step, total, message) => {
+    console.log();
+    console.log(chalk3.bold(`Step ${step}/${total}: ${message}`));
+    console.log(chalk3.gray("\u2500".repeat(40)));
+  },
+  box: (lines) => {
+    const maxLen = Math.max(...lines.map((l) => l.length));
+    const border = "\u2550".repeat(maxLen + 4);
+    console.log(chalk3.cyan(`\u2554${border}\u2557`));
+    lines.forEach((line) => {
+      const padding = " ".repeat(maxLen - line.length);
+      console.log(chalk3.cyan("\u2551") + `  ${line}${padding}  ` + chalk3.cyan("\u2551"));
+    });
+    console.log(chalk3.cyan(`\u255A${border}\u255D`));
+  },
+  list: (items, indent = 2) => {
+    const spaces = " ".repeat(indent);
+    items.forEach((item) => console.log(`${spaces}\u2022 ${item}`));
+  },
+  blank: () => console.log()
+};
+
+// src/index.ts
+async function runWizard(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const isInteractive = !options.yes && !options.json && !options.dryRun;
+  try {
+    if (isInteractive) {
+      printWelcome();
+    }
+    let apiKey = options.apiKey || "dk_placeholder";
+    if (isInteractive) {
+      logger.step(1, 5, "Enter your Datalyr API Key");
+      apiKey = await promptApiKey(options.apiKey);
+      logger.success("API key validated");
+    }
+    if (!options.json) {
+      logger.step(2, 5, "Analyzing your project...");
+    }
+    const spinner = options.json ? null : startSpinner("Scanning project structure...");
+    let detection = await detectFramework(cwd);
+    if (spinner) {
+      succeedSpinner(`Detected ${getFrameworkDisplayName(detection.framework)}`);
+    }
+    if (detection.framework === "unknown" || options.framework) {
+      stopSpinner();
+      if (options.framework) {
+        detection = { ...detection, framework: options.framework };
+      } else if (isInteractive) {
+        logger.warn("Could not auto-detect framework");
+        detection.framework = await promptFramework();
+      } else {
+        printError("Could not detect framework", "Use --framework to specify");
+        return false;
+      }
+    }
+    const packageManager = await detectPackageManager(cwd);
+    const entryPoints = await findEntryPoints(cwd, detection.framework);
+    const context = {
+      cwd,
+      framework: detection.framework,
+      sdks: detection.sdks,
+      language: detection.language,
+      packageManager,
+      entryPoints,
+      existingFiles: []
+    };
+    if (isInteractive) {
+      printDetection({
+        framework: getFrameworkDisplayName(detection.framework),
+        language: detection.language === "typescript" ? "TypeScript" : "JavaScript",
+        sdks: detection.sdks
+      });
+    }
+    if (!options.json && !options.dryRun) {
+      logger.step(3, 5, "Installation Plan");
+    }
+    const plan = generateInstallationPlan(context, apiKey);
+    if (options.dryRun) {
+      const commands = [
+        `${packageManager} add ${plan.packages.join(" ")}`
+      ];
+      printDryRun({
+        packages: plan.packages,
+        files: plan.files,
+        commands
+      });
+      return true;
+    }
+    if (options.json) {
+      console.log(JSON.stringify({
+        framework: detection.framework,
+        language: detection.language,
+        sdks: detection.sdks,
+        packages: plan.packages,
+        files: plan.files.map((f) => ({ path: f.path, action: f.action })),
+        envVars: plan.envVars.map((v) => v.key)
+      }, null, 2));
+      return true;
+    }
+    printPlan({
+      packages: plan.packages,
+      files: plan.files
+    });
+    if (isInteractive) {
+      const proceed = await promptProceed();
+      if (!proceed) {
+        logger.info("Installation cancelled");
+        return false;
+      }
+    }
+    logger.step(4, 5, "Installing...");
+    if (plan.packages.length > 0) {
+      const success = await installPackages(cwd, plan.packages);
+      if (!success) {
+        printError("Failed to install packages");
+        return false;
+      }
+    }
+    for (const file of plan.files) {
+      const filePath = path5.join(cwd, file.path);
+      const exists = await fileExists(filePath);
+      if (exists && file.action === "create") {
+        logger.warn(`Skipping ${file.path} (already exists)`);
+        continue;
+      }
+      const fileSpinner = startSpinner(`Creating ${file.path}...`);
+      await writeFile(filePath, file.content);
+      succeedSpinner(`Created ${file.path}`);
+    }
+    if (plan.envVars.length > 0) {
+      await updateEnvFile(cwd, plan.envVars);
+    }
+    logger.step(5, 5, "Success!");
+    printSuccess();
+    if (plan.postInstallSteps.length > 0) {
+      logger.header("Next steps:");
+      plan.postInstallSteps.forEach((step, i) => {
+        console.log(`  ${i + 1}. ${step}`);
+      });
+      console.log();
+    }
+    return true;
+  } catch (error) {
+    stopSpinner();
+    printError(
+      error instanceof Error ? error.message : "Unknown error occurred",
+      options.debug ? error.stack : void 0
+    );
+    return false;
+  }
+}
+async function findEntryPoints(cwd, framework) {
+  const entryPoints = [];
+  switch (framework) {
+    case "nextjs":
+      const appLayouts = await findFiles(cwd, "app/layout.{tsx,jsx,ts,js}");
+      entryPoints.push(...appLayouts);
+      const pagesApps = await findFiles(cwd, "pages/_app.{tsx,jsx,ts,js}");
+      entryPoints.push(...pagesApps);
+      break;
+    case "react":
+    case "react-vite":
+      const mains = await findFiles(cwd, "src/main.{tsx,jsx,ts,js}");
+      entryPoints.push(...mains);
+      const apps = await findFiles(cwd, "src/App.{tsx,jsx,ts,js}");
+      entryPoints.push(...apps);
+      break;
+    case "react-native":
+    case "expo":
+      const appFiles = await findFiles(cwd, "App.{tsx,jsx,ts,js}");
+      entryPoints.push(...appFiles);
+      break;
+  }
+  return entryPoints;
+}
+export {
+  detectFramework,
+  generateInstallationPlan,
+  runWizard
+};
+//# sourceMappingURL=index.mjs.map