@posthog/wizard 2.9.1 → 2.10.0

package/dist/registry-s55_iuJT.js

@@ -0,0 +1,2922 @@
+import { t as __exportAll } from "./rolldown-runtime-B_-DWIq7.js";
+import { c as getUI } from "./debug-CyJ_3dTP.js";
+import "./analytics-C4jO5Qda.js";
+import { i as createVersionBucket, r as tryGetPackageJson, s as detectAllPackageManagers } from "./setup-utils-CdDnllRW.js";
+import { n as getPackageVersion, r as hasPackageInstalled, t as getInstalledPackageVersion } from "./package-json-Ctq6LSl8.js";
+import { a as gradlePackageManager, c as getPackageManagerName$1, i as detectPythonPackageManagers, l as getPythonVersion, n as composerPackageManager, o as swiftPackageManager, r as detectNodePackageManagers, s as detectPackageManager$1, t as bundlerPackageManager, u as getPythonVersionBucket } from "./package-manager-nUQ-ebjr.js";
+import * as semver from "semver";
+import { major, minVersion } from "semver";
+import * as fs$1 from "node:fs";
+import * as path$1 from "node:path";
+import path from "path";
+import fg from "fast-glob";
+import fs from "fs/promises";
+//#region src/lib/framework-config.ts
+/**
+* Default package installation instruction used when frameworks don't
+* provide their own. Frameworks with specific needs (e.g., Swift SPM,
+* Composer) override this in their config.
+*/
+const DEFAULT_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. Do not manually edit package.json; the package manager handles it automatically.";
+const PYTHON_PACKAGE_INSTALLATION = "Use the detect_package_manager tool to determine the package manager. If the detected tool manages dependencies directly (e.g. uv add, poetry add), use it — it will update the manifest automatically. If using pip, you must also add the dependency to requirements.txt or the appropriate manifest file.";
+/**
+* Shared spinner message for all frameworks
+*/
+const SPINNER_MESSAGE = "Writing your PostHog setup with events, error capture and more...";
+//#endregion
+//#region src/frameworks/nextjs/utils.ts
+const getNextJsVersionBucket = createVersionBucket();
+const IGNORE_PATTERNS$9 = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/public/**",
+	"**/.next/**"
+];
+/**
+* Detect Next.js router type. Pure — returns null if ambiguous.
+*/
+async function getNextJsRouter({ installDir }) {
+	const hasPagesDir = (await fg("**/pages/_app.@(ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$9
+	})).length > 0;
+	const hasAppDir = (await fg("**/app/**/layout.@(ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$9
+	})).length > 0;
+	if (hasPagesDir && !hasAppDir) return "pages-router";
+	if (hasAppDir && !hasPagesDir) return "app-router";
+	return null;
+}
+const getNextJsRouterName = (router) => {
+	return router === "app-router" ? "app router" : "pages router";
+};
+//#endregion
+//#region src/frameworks/nextjs/nextjs-wizard-agent.ts
+const NEXTJS_AGENT_CONFIG = {
+	metadata: {
+		name: "Next.js",
+		integration: "nextjs",
+		docsUrl: "https://posthog.com/docs/libraries/next-js",
+		unsupportedVersionDocsUrl: "https://posthog.com/docs/libraries/next-js",
+		gatherContext: async (options) => {
+			const router = await getNextJsRouter(options);
+			if (router) {
+				const emoji = router === "app-router" ? "📱" : "📃";
+				getUI().setDetectedFramework(`Next.js ${getNextJsRouterName(router)} ${emoji}`);
+				return { router };
+			}
+			return {};
+		},
+		setup: { questions: [{
+			key: "router",
+			message: "Which Next.js router are you using?",
+			options: [{
+				label: "App Router",
+				value: "app-router"
+			}, {
+				label: "Pages Router",
+				value: "pages-router"
+			}],
+			detect: async (opts) => {
+				return await getNextJsRouter(opts);
+			}
+		}] }
+	},
+	detection: {
+		packageName: "next",
+		packageDisplayName: "Next.js",
+		getVersion: (packageJson) => getPackageVersion("next", packageJson),
+		getVersionBucket: getNextJsVersionBucket,
+		minimumVersion: "15.3.0",
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("next", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("next", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: true,
+		getEnvVars: (apiKey, host) => ({
+			NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN: apiKey,
+			NEXT_PUBLIC_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ router: context.router === "app-router" ? "app" : "pages" }) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: (context) => {
+			return [`Router: ${context.router === "app-router" ? "app" : "pages"}`];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 8,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your Next.js project structure (${getNextJsRouterName(context.router ?? "app-router")})`,
+				`Created and configured PostHog initializers`,
+				`Integrated PostHog into your application`
+			];
+		},
+		getOutroNextSteps: () => {
+			return ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"];
+		}
+	}
+};
+//#endregion
+//#region src/frameworks/nuxt/nuxt-wizard-agent.ts
+const getNuxtVersionBucket = createVersionBucket();
+const NUXT_AGENT_CONFIG = {
+	metadata: {
+		name: "Nuxt",
+		integration: "nuxt",
+		docsUrl: "https://posthog.com/docs/libraries/nuxt",
+		beta: true,
+		gatherContext: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			if (!packageJson) return {};
+			return { versionBucket: getNuxtVersionBucket(getPackageVersion("nuxt", packageJson)) };
+		}
+	},
+	detection: {
+		packageName: "nuxt",
+		packageDisplayName: "Nuxt",
+		getVersion: (packageJson) => getPackageVersion("nuxt", packageJson),
+		getVersionBucket: getNuxtVersionBucket,
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("nuxt", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("nuxt", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: true,
+		getEnvVars: (apiKey, host) => ({
+			NUXT_PUBLIC_POSTHOG_PROJECT_TOKEN: apiKey,
+			NUXT_PUBLIC_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ ...context.versionBucket ? { versionBucket: context.versionBucket } : {} }) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: (context) => {
+			const lines = [];
+			if (context.versionBucket) lines.push(`Nuxt version: ${context.versionBucket}`);
+			const frameworkId = "nuxt";
+			lines.push(`Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`);
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: () => [
+			"Analyzed your Nuxt project structure",
+			"Configured PostHog module/plugin",
+			"Integrated PostHog into your application"
+		],
+		getOutroNextSteps: () => ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"]
+	}
+};
+const VUE_AGENT_CONFIG = {
+	metadata: {
+		name: "Vue",
+		integration: "vue",
+		docsUrl: "https://posthog.com/docs/libraries/vue",
+		beta: true
+	},
+	detection: {
+		packageName: "vue",
+		packageDisplayName: "Vue",
+		getVersion: (packageJson) => getPackageVersion("vue", packageJson),
+		getVersionBucket: createVersionBucket(),
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("vue", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("vue", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: true,
+		getEnvVars: (apiKey, host) => ({
+			VITE_POSTHOG_PROJECT_TOKEN: apiKey,
+			VITE_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: () => ({}) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: () => {
+			const frameworkId = "vue";
+			return [`Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: () => [
+			"Analyzed your Vue project structure",
+			"Created and configured PostHog initializers",
+			"Integrated PostHog into your application"
+		],
+		getOutroNextSteps: () => ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"]
+	}
+};
+//#endregion
+//#region src/frameworks/react-router/utils.ts
+const IGNORE_PATTERNS$8 = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/public/**",
+	"**/.next/**"
+];
+const getReactRouterVersionBucket = createVersionBucket();
+async function hasReactRouterConfig({ installDir }) {
+	return (await fg("**/react-router.config.@(ts|js|tsx|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$8
+	})).length > 0;
+}
+async function hasCreateBrowserRouter({ installDir }) {
+	const sourceFiles = await fg("**/*.@(ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$8
+	});
+	for (const file of sourceFiles) try {
+		const filePath = path$1.join(installDir, file);
+		if (fs$1.readFileSync(filePath, "utf-8").includes("createBrowserRouter")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+async function hasDeclarativeRouter({ installDir }) {
+	const sourceFiles = await fg("**/*.@(ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$8
+	});
+	for (const file of sourceFiles) try {
+		const filePath = path$1.join(installDir, file);
+		const content = fs$1.readFileSync(filePath, "utf-8");
+		if (content.includes("<BrowserRouter") || content.includes("BrowserRouter") && (content.includes("from \"react-router-dom\"") || content.includes("from 'react-router-dom'"))) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Detect React Router mode. Pure — returns null if ambiguous.
+*/
+async function getReactRouterMode(options) {
+	const { installDir } = options;
+	const packageJson = await tryGetPackageJson(options);
+	if (!packageJson) return null;
+	const reactRouterVersion = getPackageVersion("react-router-dom", packageJson) || getPackageVersion("react-router", packageJson);
+	if (!reactRouterVersion) return null;
+	const coercedVersion = semver.coerce(reactRouterVersion);
+	const majorVersion = coercedVersion ? major(coercedVersion) : null;
+	if (majorVersion === 6) return "v6";
+	if (majorVersion === 7) {
+		if (await hasReactRouterConfig({ installDir })) return "v7-framework";
+		if (await hasCreateBrowserRouter({ installDir })) return "v7-data";
+		if (await hasDeclarativeRouter({ installDir })) return "v7-declarative";
+		return null;
+	}
+	return null;
+}
+function getReactRouterModeName(mode) {
+	switch (mode) {
+		case "v6": return "v6";
+		case "v7-framework": return "v7 Framework mode";
+		case "v7-data": return "v7 Data mode";
+		case "v7-declarative": return "v7 Declarative mode";
+	}
+}
+//#endregion
+//#region src/frameworks/react-router/react-router-wizard-agent.ts
+const REACT_ROUTER_AGENT_CONFIG = {
+	metadata: {
+		name: "React Router",
+		integration: "react-router",
+		docsUrl: "https://posthog.com/docs/libraries/react",
+		unsupportedVersionDocsUrl: "https://posthog.com/docs/libraries/react",
+		gatherContext: async (options) => {
+			const routerMode = await getReactRouterMode(options);
+			if (routerMode) {
+				getUI().setDetectedFramework(`React Router ${getReactRouterModeName(routerMode)}`);
+				return { routerMode };
+			}
+			return {};
+		}
+	},
+	detection: {
+		packageName: "react-router",
+		packageDisplayName: "React Router",
+		getVersion: (packageJson) => getPackageVersion("react-router", packageJson),
+		getVersionBucket: getReactRouterVersionBucket,
+		minimumVersion: "6.0.0",
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("react-router", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("react-router", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			REACT_APP_POSTHOG_PROJECT_TOKEN: apiKey,
+			REACT_APP_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ routerMode: context.routerMode || "unknown" }) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: (context) => {
+			const routerMode = context.routerMode;
+			const modeName = routerMode ? getReactRouterModeName(routerMode) : "unknown";
+			const frameworkId = routerMode ? {
+				["v6"]: "react-react-router-6",
+				["v7-framework"]: "react-react-router-7-framework",
+				["v7-data"]: "react-react-router-7-data",
+				["v7-declarative"]: "react-react-router-7-declarative"
+			}[routerMode] : "v7-framework";
+			return [`Router mode: ${modeName}`, `Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 8,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your React Router project structure (${context.routerMode ? getReactRouterModeName(context.routerMode) : "React Router"})`,
+				`Created and configured PostHog initializers`,
+				`Integrated PostHog into your application`
+			];
+		},
+		getOutroNextSteps: () => ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"]
+	}
+};
+//#endregion
+//#region src/frameworks/tanstack-router/utils.ts
+const IGNORE_PATTERNS$7 = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/public/**",
+	"**/.vinxi/**",
+	"**/.output/**"
+];
+const getTanStackRouterVersionBucket = createVersionBucket();
+async function hasFileBasedRouting({ installDir }) {
+	if ((await fg("**/routeTree.gen.@(ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$7
+	})).length > 0) return true;
+	try {
+		const packageJsonPath = path$1.join(installDir, "package.json");
+		const content = fs$1.readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		if (hasPackageInstalled("@tanstack/router-plugin", packageJson) || hasPackageInstalled("@tanstack/router-vite-plugin", packageJson)) return true;
+	} catch {}
+	const sourceFiles = await fg("**/*.@(ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$7
+	});
+	for (const file of sourceFiles) try {
+		const filePath = path$1.join(installDir, file);
+		if (fs$1.readFileSync(filePath, "utf-8").includes("createFileRoute")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+async function hasCodeBasedRouting({ installDir }) {
+	const sourceFiles = await fg("**/*.@(ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$7
+	});
+	let hasCreateRoute = false;
+	let hasCreateFileRoute = false;
+	for (const file of sourceFiles) try {
+		const filePath = path$1.join(installDir, file);
+		const content = fs$1.readFileSync(filePath, "utf-8");
+		if (content.includes("createRoute(")) hasCreateRoute = true;
+		if (content.includes("createFileRoute")) hasCreateFileRoute = true;
+	} catch {
+		continue;
+	}
+	return hasCreateRoute && !hasCreateFileRoute;
+}
+/**
+* Detect TanStack Router mode. Pure — returns null if ambiguous.
+*/
+async function getTanStackRouterMode(options) {
+	const { installDir } = options;
+	if (await hasFileBasedRouting({ installDir })) return "file-based";
+	if (await hasCodeBasedRouting({ installDir })) return "code-based";
+	return null;
+}
+function getTanStackRouterModeName(mode) {
+	switch (mode) {
+		case "file-based": return "File-based routing";
+		case "code-based": return "Code-based routing";
+	}
+}
+//#endregion
+//#region src/frameworks/tanstack-router/tanstack-router-wizard-agent.ts
+const TANSTACK_ROUTER_AGENT_CONFIG = {
+	metadata: {
+		name: "React (TanStack Router)",
+		integration: "tanstack-router",
+		docsUrl: "https://posthog.com/docs/libraries/react",
+		gatherContext: async (options) => {
+			const routerMode = await getTanStackRouterMode(options);
+			if (routerMode) {
+				getUI().setDetectedFramework(`TanStack Router ${getTanStackRouterModeName(routerMode)}`);
+				return { routerMode };
+			}
+			return {};
+		}
+	},
+	detection: {
+		packageName: "@tanstack/react-router",
+		packageDisplayName: "TanStack Router",
+		getVersion: (packageJson) => getPackageVersion("@tanstack/react-router", packageJson),
+		getVersionBucket: getTanStackRouterVersionBucket,
+		minimumVersion: "1.0.0",
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("@tanstack/react-router", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			if (!packageJson) return false;
+			if (hasPackageInstalled("@tanstack/react-start", packageJson)) return false;
+			return hasPackageInstalled("@tanstack/react-router", packageJson);
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			VITE_PUBLIC_POSTHOG_PROJECT_TOKEN: apiKey,
+			VITE_PUBLIC_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ routerMode: context.routerMode || "unknown" }) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: (context) => {
+			const routerMode = context.routerMode;
+			const modeName = routerMode ? getTanStackRouterModeName(routerMode) : "unknown";
+			const frameworkId = routerMode ? {
+				["file-based"]: "react-tanstack-router-file-based",
+				["code-based"]: "react-tanstack-router-code-based"
+			}[routerMode] : "react-tanstack-router-file-based";
+			return [`Router mode: ${modeName}`, `Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 8,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your React (TanStack Router) project structure (${context.routerMode ? getTanStackRouterModeName(context.routerMode) : "TanStack Router"})`,
+				`Created and configured PostHog initializers`,
+				`Integrated PostHog into your application`
+			];
+		},
+		getOutroNextSteps: () => ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"]
+	}
+};
+//#endregion
+//#region src/frameworks/tanstack-start/tanstack-start-wizard-agent.ts
+const TANSTACK_START_AGENT_CONFIG = {
+	metadata: {
+		name: "TanStack Start",
+		integration: "tanstack-start",
+		docsUrl: "https://posthog.com/docs/libraries/react"
+	},
+	detection: {
+		packageName: "@tanstack/react-start",
+		packageDisplayName: "TanStack Start",
+		getVersion: (packageJson) => getPackageVersion("@tanstack/react-start", packageJson),
+		getVersionBucket: createVersionBucket(),
+		minimumVersion: "1.0.0",
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("@tanstack/react-start", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("@tanstack/react-start", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			VITE_PUBLIC_POSTHOG_PROJECT_TOKEN: apiKey,
+			VITE_PUBLIC_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: () => ({}) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: () => {
+			const frameworkId = "react-tanstack-start";
+			return [`Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 8,
+		getOutroChanges: () => [
+			`Analyzed your TanStack Start project structure`,
+			`Created and configured PostHog initializers`,
+			`Integrated PostHog into your application`
+		],
+		getOutroNextSteps: () => ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"]
+	}
+};
+//#endregion
+//#region src/frameworks/react-native/utils.ts
+const getReactNativeVersionBucket = createVersionBucket();
+function getReactNativeVariantName(variant) {
+	return variant === "expo" ? "Expo" : "React Native";
+}
+async function detectReactNativeVariant(options) {
+	const packageJson = await tryGetPackageJson(options);
+	if (packageJson && hasPackageInstalled("expo", packageJson)) {
+		getUI().setDetectedFramework(`${getReactNativeVariantName("expo")} 📱`);
+		return "expo";
+	}
+	getUI().setDetectedFramework(`${getReactNativeVariantName("react-native")} 📱`);
+	return "react-native";
+}
+//#endregion
+//#region src/frameworks/react-native/react-native-wizard-agent.ts
+const REACT_NATIVE_AGENT_CONFIG = {
+	metadata: {
+		name: "React Native",
+		integration: "react-native",
+		docsUrl: "https://posthog.com/docs/libraries/react-native",
+		gatherContext: async (options) => {
+			return { variant: await detectReactNativeVariant(options) };
+		}
+	},
+	detection: {
+		packageName: "react-native",
+		packageDisplayName: "React Native",
+		getVersion: (packageJson) => getPackageVersion("react-native", packageJson),
+		getVersionBucket: getReactNativeVersionBucket,
+		minimumVersion: "0.73.0",
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("react-native", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("react-native", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ variant: context.variant === "expo" ? "expo" : "react-native" }) },
+	prompts: {
+		projectTypeDetection: "This is a React Native project. Look for package.json, android/ and ios/ directories, and lockfiles to confirm. Check for expo in package.json to determine the variant.",
+		getAdditionalContextLines: (context) => {
+			const isExpo = context.variant === "expo";
+			const frameworkId = "react-native";
+			const lines = [`Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`, `Variant: ${isExpo ? "Expo" : "React Native"}`];
+			if (isExpo) lines.push("Use `npx expo install` for package installation.", "Use EXPO_PUBLIC_ prefix for environment variables exposed to the client.");
+			else lines.push("This is a React Native project without Expo. Native linking may be required.", "For iOS, ensure pods are installed after adding PostHog.");
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 10,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your React Native project structure (${getReactNativeVariantName(context.variant ?? "react-native")})`,
+				`Installed and configured the PostHog React Native SDK`,
+				`Integrated PostHog into your application`
+			];
+		},
+		getOutroNextSteps: (context) => {
+			const isExpo = context.variant === "expo";
+			const steps = [];
+			if (!isExpo) steps.push("Run `npx pod-install` to install iOS dependencies");
+			steps.push(isExpo ? "Start your development server with `npx expo start` to see PostHog in action" : "Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events");
+			return steps;
+		}
+	}
+};
+//#endregion
+//#region src/frameworks/angular/angular-wizard-agent.ts
+const ANGULAR_AGENT_CONFIG = {
+	metadata: {
+		name: "Angular",
+		integration: "angular",
+		docsUrl: "https://posthog.com/docs/libraries/angular"
+	},
+	detection: {
+		packageName: "@angular/core",
+		packageDisplayName: "Angular",
+		getVersion: (packageJson) => getPackageVersion("@angular/core", packageJson),
+		getVersionBucket: createVersionBucket(),
+		minimumVersion: "19.0.0",
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("@angular/core", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("@angular/core", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			NG_APP_POSTHOG_PROJECT_TOKEN: apiKey,
+			NG_APP_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: () => ({}) },
+	prompts: {
+		projectTypeDetection: "This is an Angular project. Look for package.json, angular.json, and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml) to confirm.",
+		getAdditionalContextLines: () => {
+			const frameworkId = "angular";
+			return [
+				`Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`,
+				"Angular uses dependency injection for services. PostHog should be initialized as a service.",
+				"For standalone components, ensure PostHog is properly provided in the application config."
+			];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 8,
+		getOutroChanges: () => [
+			`Analyzed your Angular project structure`,
+			`Created and configured PostHog service`,
+			`Integrated PostHog into your application`
+		],
+		getOutroNextSteps: () => ["Start your development server with `ng serve` to see PostHog in action", "Visit your PostHog dashboard to see incoming events"]
+	}
+};
+//#endregion
+//#region src/frameworks/astro/utils.ts
+const getAstroVersionBucket = createVersionBucket();
+const IGNORE_PATTERNS$6 = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.astro/**"
+];
+/**
+* Detect the Astro rendering mode. Pure — always resolves (Astro detection is reliable).
+*/
+async function getAstroRenderingMode({ installDir }) {
+	const configMatches = await fg("astro.config.@(mjs|ts|js)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$6
+	});
+	let hasAdapter = false;
+	let outputMode = null;
+	let usesViewTransitions = false;
+	try {
+		const packageJsonPath = path.join(installDir, "package.json");
+		const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(packageJsonContent);
+		const allDeps = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies
+		};
+		hasAdapter = Object.keys(allDeps).some((dep) => dep.startsWith("@astrojs/") && (dep.includes("node") || dep.includes("vercel") || dep.includes("netlify") || dep.includes("cloudflare") || dep.includes("deno")));
+	} catch {}
+	if (configMatches.length > 0) try {
+		const configPath = path.join(installDir, configMatches[0]);
+		const outputMatch = (await fs.readFile(configPath, "utf-8")).match(/output:\s*['"](\w+)['"]/);
+		if (outputMatch) outputMode = outputMatch[1];
+	} catch {}
+	const viewTransitionMatches = await fg("**/*.@(astro|ts|tsx|js|jsx)", {
+		dot: true,
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$6
+	});
+	for (const file of viewTransitionMatches.slice(0, 20)) try {
+		const filePath = path.join(installDir, file);
+		const content = await fs.readFile(filePath, "utf-8");
+		if (content.includes("ClientRouter") || content.includes("ViewTransitions") || content.includes("astro:transitions")) {
+			usesViewTransitions = true;
+			break;
+		}
+	} catch {}
+	if (usesViewTransitions) return "view-transitions";
+	if (outputMode === "server" && hasAdapter) return "ssr";
+	if (hasAdapter) return "hybrid";
+	return "static";
+}
+const getAstroRenderingModeName = (mode) => {
+	switch (mode) {
+		case "static": return "Static (SSG)";
+		case "view-transitions": return "View Transitions";
+		case "ssr": return "Server (SSR)";
+		case "hybrid": return "Hybrid";
+		default: return "Static";
+	}
+};
+//#endregion
+//#region src/frameworks/astro/astro-wizard-agent.ts
+const ASTRO_AGENT_CONFIG = {
+	metadata: {
+		name: "Astro",
+		integration: "astro",
+		docsUrl: "https://posthog.com/docs/libraries/astro",
+		gatherContext: async (options) => {
+			const renderingMode = await getAstroRenderingMode(options);
+			getUI().setDetectedFramework(`Astro ${getAstroRenderingModeName(renderingMode)}`);
+			return { renderingMode };
+		}
+	},
+	detection: {
+		packageName: "astro",
+		packageDisplayName: "Astro",
+		getVersion: (packageJson) => getPackageVersion("astro", packageJson),
+		getVersionBucket: getAstroVersionBucket,
+		minimumVersion: "4.0.0",
+		getInstalledVersion: (options) => Promise.resolve(getInstalledPackageVersion("astro", options.installDir)),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("astro", packageJson) : false;
+		},
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: true,
+		getEnvVars: (apiKey, host) => ({
+			PUBLIC_POSTHOG_PROJECT_TOKEN: apiKey,
+			PUBLIC_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ "rendering-mode": context.renderingMode ?? "static" }) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: (context) => {
+			const modeName = getAstroRenderingModeName(context.renderingMode ?? "static");
+			const frameworkId = {
+				["static"]: "astro-static",
+				["view-transitions"]: "astro-view-transitions",
+				["ssr"]: "astro-ssr",
+				["hybrid"]: "astro-hybrid"
+			}[context.renderingMode ?? "static"];
+			const lines = [`Rendering mode: ${modeName}`, `Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+			if (context.renderingMode === "view-transitions") {
+				lines.push("IMPORTANT: Use window.__posthog_initialized guard to prevent re-initialization during soft navigation");
+				lines.push("IMPORTANT: Set capture_pageview: 'history_change' for automatic pageview tracking");
+			}
+			if (context.renderingMode === "ssr" || context.renderingMode === "hybrid") {
+				lines.push("IMPORTANT: Use posthog-node for server-side tracking in API routes");
+				lines.push("IMPORTANT: Create a singleton pattern for the posthog-node client");
+			}
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 6,
+		getOutroChanges: (context) => {
+			const changes = [
+				`Analyzed your Astro project structure (${getAstroRenderingModeName(context.renderingMode ?? "static")})`,
+				`Created PostHog component with is:inline script`,
+				`Integrated PostHog into your layout`
+			];
+			if (context.renderingMode === "ssr" || context.renderingMode === "hybrid") changes.push(`Set up posthog-node for server-side tracking`);
+			if (context.renderingMode === "view-transitions") changes.push(`Added initialization guard for view transitions compatibility`);
+			return changes;
+		},
+		getOutroNextSteps: () => {
+			return ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"];
+		}
+	}
+};
+//#endregion
+//#region src/frameworks/django/utils.ts
+const IGNORE_PATTERNS$5 = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/venv/**",
+	"**/.venv/**",
+	"**/env/**",
+	"**/.env/**",
+	"**/__pycache__/**",
+	"**/migrations/**"
+];
+/**
+* Get Django version bucket for analytics
+*/
+const getDjangoVersionBucket = createVersionBucket();
+/**
+* Extract Django version from requirements files or pyproject.toml
+*/
+async function getDjangoVersion(options) {
+	const { installDir } = options;
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/setup.py",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$5
+	});
+	for (const reqFile of requirementsFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+		const requirementsMatch = content.match(/[Dd]jango[=<>~!]+([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+		if (requirementsMatch) return requirementsMatch[1];
+		const pyprojectMatch = content.match(/[Dd]jango["\s]*[=<>~!]+\s*["']?([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+		if (pyprojectMatch) return pyprojectMatch[1];
+	} catch {
+		continue;
+	}
+}
+/**
+* Check if Django REST Framework is installed
+*/
+async function hasDRF({ installDir }) {
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$5
+	});
+	for (const reqFile of requirementsFiles) try {
+		if (fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8").includes("djangorestframework")) return true;
+	} catch {
+		continue;
+	}
+	const settingsFiles = await fg("**/settings.py", {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$5
+	});
+	for (const settingsFile of settingsFiles) try {
+		if (fs$1.readFileSync(path$1.join(installDir, settingsFile), "utf-8").includes("rest_framework")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Check if Wagtail is installed
+*/
+async function hasWagtail({ installDir }) {
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$5
+	});
+	for (const reqFile of requirementsFiles) try {
+		if (fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8").includes("wagtail")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Check if Django Channels is installed
+*/
+async function hasChannels({ installDir }) {
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$5
+	});
+	for (const reqFile of requirementsFiles) try {
+		if (fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8").includes("channels")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Detect Django project type
+*/
+async function getDjangoProjectType(options) {
+	const { installDir } = options;
+	if (await hasWagtail({ installDir })) {
+		getUI().setDetectedFramework("Django with Wagtail CMS");
+		return "wagtail";
+	}
+	if (await hasDRF({ installDir })) {
+		getUI().setDetectedFramework("Django REST Framework");
+		return "drf";
+	}
+	if (await hasChannels({ installDir })) {
+		getUI().setDetectedFramework("Django Channels");
+		return "channels";
+	}
+	getUI().setDetectedFramework("Django");
+	return "standard";
+}
+/**
+* Get human-readable name for Django project type
+*/
+function getDjangoProjectTypeName(projectType) {
+	switch (projectType) {
+		case "standard": return "Standard Django";
+		case "drf": return "Django REST Framework";
+		case "wagtail": return "Wagtail CMS";
+		case "channels": return "Django Channels";
+	}
+}
+/**
+* Find the main Django settings file
+*/
+async function findDjangoSettingsFile(options) {
+	const { installDir } = options;
+	const settingsFiles = await fg("**/settings.py", {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$5
+	});
+	if (settingsFiles.length === 0) {
+		const splitSettingsFiles = await fg("**/settings/__init__.py", {
+			cwd: installDir,
+			ignore: IGNORE_PATTERNS$5
+		});
+		if (splitSettingsFiles.length > 0) return splitSettingsFiles[0];
+		return;
+	}
+	if (settingsFiles.length === 1) return settingsFiles[0];
+	for (const settingsFile of settingsFiles) try {
+		if (fs$1.readFileSync(path$1.join(installDir, settingsFile), "utf-8").includes("ROOT_URLCONF")) return settingsFile;
+	} catch {
+		continue;
+	}
+	return settingsFiles[0];
+}
+//#endregion
+//#region src/frameworks/django/django-wizard-agent.ts
+const DJANGO_AGENT_CONFIG = {
+	metadata: {
+		name: "Django",
+		integration: "django",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/django",
+		unsupportedVersionDocsUrl: "https://posthog.com/docs/libraries/python",
+		gatherContext: async (options) => {
+			return {
+				projectType: await getDjangoProjectType(options),
+				settingsFile: await findDjangoSettingsFile(options)
+			};
+		}
+	},
+	detection: {
+		packageName: "django",
+		packageDisplayName: "Django",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		getVersionBucket: getDjangoVersionBucket,
+		minimumVersion: "3.0.0",
+		getInstalledVersion: (options) => getDjangoVersion(options),
+		detect: async (options) => {
+			const { installDir } = options;
+			const managePyMatches = await fg("**/manage.py", {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**"
+				]
+			});
+			if (managePyMatches.length > 0) for (const match of managePyMatches) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, match), "utf-8");
+				if (content.includes("from django") || content.includes("import django") || content.includes("DJANGO_SETTINGS_MODULE") || /execute_from_command_line/.test(content)) return true;
+			} catch {
+				continue;
+			}
+			const requirementsFiles = await fg([
+				"**/requirements*.txt",
+				"**/pyproject.toml",
+				"**/setup.py"
+			], {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**"
+				]
+			});
+			for (const reqFile of requirementsFiles) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+				if (/^django([>=~!<\s]|$)/im.test(content) || /["']django["']/i.test(content)) return true;
+			} catch {
+				continue;
+			}
+			return false;
+		},
+		detectPackageManager: detectPythonPackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ projectType: context.projectType || "unknown" }) },
+	prompts: {
+		packageInstallation: PYTHON_PACKAGE_INSTALLATION,
+		projectTypeDetection: "This is a Python/Django project. Look for requirements.txt, pyproject.toml, setup.py, Pipfile, or manage.py to confirm.",
+		getAdditionalContextLines: (context) => {
+			const projectTypeName = context.projectType ? getDjangoProjectTypeName(context.projectType) : "unknown";
+			const frameworkId = context.projectType ? {
+				["standard"]: "django",
+				["drf"]: "django",
+				["wagtail"]: "django",
+				["channels"]: "django"
+			}[context.projectType] : "django";
+			const lines = [`Project type: ${projectTypeName}`, `Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+			if (context.settingsFile) lines.push(`Settings file: ${context.settingsFile}`);
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your ${context.projectType ? getDjangoProjectTypeName(context.projectType) : "Django"} project structure`,
+				`Installed the PostHog Python package`,
+				`Configured PostHog in your Django settings`,
+				`Added PostHog middleware for automatic event tracking`
+			];
+		},
+		getOutroNextSteps: () => [
+			"Start your Django development server to see PostHog in action",
+			"Visit your PostHog dashboard to see incoming events",
+			"Use identify_context() within new_context() to associate events with users"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/flask/utils.ts
+const IGNORE_PATTERNS$4 = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/venv/**",
+	"**/.venv/**",
+	"**/env/**",
+	"**/.env/**",
+	"**/__pycache__/**",
+	"**/migrations/**",
+	"**/instance/**"
+];
+/**
+* Get Flask version bucket for analytics
+*/
+const getFlaskVersionBucket = createVersionBucket();
+/**
+* Extract Flask version from requirements files or pyproject.toml
+*/
+async function getFlaskVersion(options) {
+	const { installDir } = options;
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/setup.py",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const reqFile of requirementsFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+		const requirementsMatch = content.match(/[Ff]lask[=<>~!]+([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+		if (requirementsMatch) return requirementsMatch[1];
+		const pyprojectMatch = content.match(/[Ff]lask["\s]*[=<>~!]+\s*["']?([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+		if (pyprojectMatch) return pyprojectMatch[1];
+	} catch {
+		continue;
+	}
+}
+/**
+* Check if Flask-RESTful is installed
+*/
+async function hasFlaskRESTful({ installDir }) {
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const reqFile of requirementsFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+		if (content.includes("flask-restful") || content.includes("Flask-RESTful")) return true;
+	} catch {
+		continue;
+	}
+	const pyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const pyFile of pyFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+		if (content.includes("from flask_restful import") || content.includes("import flask_restful")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Check if Flask-RESTX is installed
+*/
+async function hasFlaskRESTX({ installDir }) {
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const reqFile of requirementsFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+		if (content.includes("flask-restx") || content.includes("Flask-RESTX")) return true;
+	} catch {
+		continue;
+	}
+	const pyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const pyFile of pyFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+		if (content.includes("from flask_restx import") || content.includes("import flask_restx")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Check if flask-smorest is installed
+*/
+async function hasFlaskSmorest({ installDir }) {
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const reqFile of requirementsFiles) try {
+		if (fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8").includes("flask-smorest")) return true;
+	} catch {
+		continue;
+	}
+	const pyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const pyFile of pyFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+		if (content.includes("from flask_smorest import") || content.includes("import flask_smorest")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Check if app uses Flask Blueprints
+*/
+async function hasBlueprints({ installDir }) {
+	const pyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const pyFile of pyFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+		if (content.includes("Blueprint(") || content.includes("register_blueprint(") || content.includes("from flask import Blueprint")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Detect Flask project type
+*/
+async function getFlaskProjectType(options) {
+	const { installDir } = options;
+	if (await hasFlaskRESTX({ installDir })) {
+		getUI().setDetectedFramework("Flask-RESTX");
+		return "restx";
+	}
+	if (await hasFlaskSmorest({ installDir })) {
+		getUI().setDetectedFramework("flask-smorest");
+		return "smorest";
+	}
+	if (await hasFlaskRESTful({ installDir })) {
+		getUI().setDetectedFramework("Flask-RESTful");
+		return "restful";
+	}
+	if (await hasBlueprints({ installDir })) {
+		getUI().setDetectedFramework("Flask with Blueprints");
+		return "blueprint";
+	}
+	getUI().setDetectedFramework("Flask");
+	return "standard";
+}
+/**
+* Get human-readable name for Flask project type
+*/
+function getFlaskProjectTypeName(projectType) {
+	switch (projectType) {
+		case "standard": return "Standard Flask";
+		case "restful": return "Flask-RESTful";
+		case "restx": return "Flask-RESTX";
+		case "smorest": return "flask-smorest";
+		case "blueprint": return "Flask with Blueprints";
+	}
+}
+/**
+* Find the main Flask app file
+*/
+async function findFlaskAppFile(options) {
+	const { installDir } = options;
+	const appFiles = await fg([
+		"**/app.py",
+		"**/wsgi.py",
+		"**/application.py",
+		"**/run.py",
+		"**/main.py",
+		"**/__init__.py"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const appFile of appFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, appFile), "utf-8");
+		if (content.includes("Flask(__name__)") || content.includes("Flask(") || content.includes("def create_app(")) return appFile;
+	} catch {
+		continue;
+	}
+	const allPyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$4
+	});
+	for (const pyFile of allPyFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+		if (content.includes("Flask(__name__)") || content.includes("def create_app(")) return pyFile;
+	} catch {
+		continue;
+	}
+	if (appFiles.length > 0) return appFiles[0];
+}
+//#endregion
+//#region src/frameworks/flask/flask-wizard-agent.ts
+const FLASK_AGENT_CONFIG = {
+	metadata: {
+		name: "Flask",
+		integration: "flask",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/python",
+		unsupportedVersionDocsUrl: "https://posthog.com/docs/libraries/python",
+		gatherContext: async (options) => {
+			return {
+				projectType: await getFlaskProjectType(options),
+				appFile: await findFlaskAppFile(options)
+			};
+		}
+	},
+	detection: {
+		packageName: "flask",
+		packageDisplayName: "Flask",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		getVersionBucket: getFlaskVersionBucket,
+		minimumVersion: "2.0.0",
+		getInstalledVersion: (options) => getFlaskVersion(options),
+		detect: async (options) => {
+			const { installDir } = options;
+			const requirementsFiles = await fg([
+				"**/requirements*.txt",
+				"**/pyproject.toml",
+				"**/setup.py",
+				"**/Pipfile"
+			], {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**"
+				]
+			});
+			for (const reqFile of requirementsFiles) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+				if (/^flask([<>=~!]|$|\s)/im.test(content) || /["']flask["']/i.test(content)) return true;
+			} catch {
+				continue;
+			}
+			const pyFiles = await fg([
+				"**/app.py",
+				"**/wsgi.py",
+				"**/application.py",
+				"**/__init__.py"
+			], {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**",
+					"**/__pycache__/**"
+				]
+			});
+			for (const pyFile of pyFiles) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+				if (content.includes("from flask import") || content.includes("import flask") || /Flask\s*\(/.test(content)) return true;
+			} catch {
+				continue;
+			}
+			return false;
+		},
+		detectPackageManager: detectPythonPackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ projectType: context.projectType || "unknown" }) },
+	prompts: {
+		packageInstallation: PYTHON_PACKAGE_INSTALLATION,
+		projectTypeDetection: "This is a Python/Flask project. Look for requirements.txt, pyproject.toml, setup.py, Pipfile, or app.py/wsgi.py to confirm.",
+		getAdditionalContextLines: (context) => {
+			const projectTypeName = context.projectType ? getFlaskProjectTypeName(context.projectType) : "unknown";
+			const frameworkId = context.projectType ? {
+				["standard"]: "flask",
+				["restful"]: "flask",
+				["restx"]: "flask",
+				["smorest"]: "flask",
+				["blueprint"]: "flask"
+			}[context.projectType] : "flask";
+			const lines = [`Project type: ${projectTypeName}`, `Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+			if (context.appFile) lines.push(`App file: ${context.appFile}`);
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your ${context.projectType ? getFlaskProjectTypeName(context.projectType) : "Flask"} project structure`,
+				`Installed the PostHog Python package`,
+				`Configured PostHog in your Flask application`,
+				`Added PostHog initialization with automatic event tracking`
+			];
+		},
+		getOutroNextSteps: () => [
+			"Start your Flask development server to see PostHog in action",
+			"Visit your PostHog dashboard to see incoming events",
+			"Use posthog.identify() to associate events with users"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/fastapi/utils.ts
+const IGNORE_PATTERNS$3 = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/venv/**",
+	"**/.venv/**",
+	"**/env/**",
+	"**/.env/**",
+	"**/__pycache__/**",
+	"**/migrations/**"
+];
+/**
+* Get FastAPI version bucket for analytics
+*/
+function getFastAPIVersionBucket(version) {
+	if (!version) return "none";
+	try {
+		const minVer = minVersion(version);
+		if (!minVer) return "invalid";
+		const majorVersion = major(minVer);
+		if (majorVersion === 0) return "0.x";
+		return `${majorVersion}.x`;
+	} catch {
+		return "unknown";
+	}
+}
+/**
+* Extract FastAPI version from requirements files or pyproject.toml
+*/
+async function getFastAPIVersion(options) {
+	const { installDir } = options;
+	const requirementsFiles = await fg([
+		"**/requirements*.txt",
+		"**/pyproject.toml",
+		"**/setup.py",
+		"**/Pipfile"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$3
+	});
+	for (const reqFile of requirementsFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+		const requirementsMatch = content.match(/[Ff]ast[Aa][Pp][Ii][=<>~!]+([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+		if (requirementsMatch) return requirementsMatch[1];
+		const pyprojectMatch = content.match(/[Ff]ast[Aa][Pp][Ii]["\s]*[=<>~!]+\s*["']?([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+		if (pyprojectMatch) return pyprojectMatch[1];
+	} catch {
+		continue;
+	}
+}
+/**
+* Check if app uses FastAPI APIRouter
+*/
+async function hasAPIRouter({ installDir }) {
+	const pyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$3
+	});
+	for (const pyFile of pyFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+		if (content.includes("APIRouter(") || content.includes("include_router(") || content.includes("from fastapi import APIRouter")) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Check if app uses Jinja2 templates (fullstack pattern)
+*/
+async function hasTemplates({ installDir }) {
+	const pyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$3
+	});
+	for (const pyFile of pyFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+		if (content.includes("Jinja2Templates") || content.includes("from fastapi.templating import")) return true;
+	} catch {
+		continue;
+	}
+	return (await fg(["**/templates"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$3,
+		onlyDirectories: true
+	})).length > 0;
+}
+/**
+* Detect FastAPI project type
+*/
+async function getFastAPIProjectType(options) {
+	const { installDir } = options;
+	if (await hasTemplates({ installDir })) {
+		getUI().setDetectedFramework("FastAPI fullstack with templates");
+		return "fullstack";
+	}
+	if (await hasAPIRouter({ installDir })) {
+		getUI().setDetectedFramework("FastAPI with APIRouter");
+		return "router";
+	}
+	getUI().setDetectedFramework("FastAPI");
+	return "standard";
+}
+/**
+* Get human-readable name for FastAPI project type
+*/
+function getFastAPIProjectTypeName(projectType) {
+	switch (projectType) {
+		case "standard": return "Standard FastAPI";
+		case "router": return "FastAPI with APIRouter";
+		case "fullstack": return "FastAPI Fullstack";
+	}
+}
+/**
+* Find the main FastAPI app file
+*/
+async function findFastAPIAppFile(options) {
+	const { installDir } = options;
+	const appFiles = await fg([
+		"**/main.py",
+		"**/app.py",
+		"**/application.py",
+		"**/api.py",
+		"**/__init__.py"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$3
+	});
+	for (const appFile of appFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, appFile), "utf-8");
+		if (content.includes("FastAPI(") || content.includes("from fastapi import FastAPI")) return appFile;
+	} catch {
+		continue;
+	}
+	const allPyFiles = await fg(["**/*.py"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$3
+	});
+	for (const pyFile of allPyFiles) try {
+		if (fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8").includes("FastAPI(")) return pyFile;
+	} catch {
+		continue;
+	}
+	if (appFiles.length > 0) return appFiles[0];
+}
+//#endregion
+//#region src/frameworks/fastapi/fastapi-wizard-agent.ts
+/**
+* FastAPI framework configuration for the universal agent runner
+*/
+const FASTAPI_AGENT_CONFIG = {
+	metadata: {
+		name: "FastAPI",
+		integration: "fastapi",
+		docsUrl: "https://posthog.com/docs/libraries/python",
+		unsupportedVersionDocsUrl: "https://posthog.com/docs/libraries/python",
+		gatherContext: async (options) => {
+			return {
+				projectType: await getFastAPIProjectType(options),
+				appFile: await findFastAPIAppFile(options)
+			};
+		}
+	},
+	detection: {
+		packageName: "fastapi",
+		packageDisplayName: "FastAPI",
+		usesPackageJson: false,
+		getVersion: (_packageJson) => {},
+		getVersionBucket: getFastAPIVersionBucket,
+		getInstalledVersion: getFastAPIVersion,
+		detect: async (options) => {
+			const { installDir } = options;
+			const requirementsFiles = await fg([
+				"**/requirements*.txt",
+				"**/pyproject.toml",
+				"**/setup.py",
+				"**/Pipfile"
+			], {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**"
+				]
+			});
+			for (const reqFile of requirementsFiles) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, reqFile), "utf-8");
+				if (/^fastapi([<>=~!]|$|\s)/im.test(content) || /["']fastapi["']/i.test(content)) return true;
+			} catch {
+				continue;
+			}
+			const pyFiles = await fg([
+				"**/main.py",
+				"**/app.py",
+				"**/application.py",
+				"**/__init__.py"
+			], {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**",
+					"**/__pycache__/**"
+				]
+			});
+			for (const pyFile of pyFiles) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+				if (content.includes("from fastapi import") || content.includes("import fastapi") || /FastAPI\s*\(/.test(content)) return true;
+			} catch {
+				continue;
+			}
+			return false;
+		},
+		detectPackageManager: detectPythonPackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => {
+		return { projectType: context.projectType || "unknown" };
+	} },
+	prompts: {
+		packageInstallation: PYTHON_PACKAGE_INSTALLATION,
+		projectTypeDetection: "This is a Python/FastAPI project. Look for requirements.txt, pyproject.toml, setup.py, Pipfile, or main.py/app.py to confirm.",
+		getAdditionalContextLines: (context) => {
+			const projectType = context.projectType;
+			const projectTypeName = projectType ? getFastAPIProjectTypeName(projectType) : "unknown";
+			const frameworkId = projectType ? {
+				["standard"]: "fastapi",
+				["router"]: "fastapi",
+				["fullstack"]: "fastapi"
+			}[projectType] : "fastapi";
+			const lines = [`Project type: ${projectTypeName}`, `Framework docs ID: ${frameworkId} (use posthog://docs/frameworks/${frameworkId} for documentation)`];
+			if (context.appFile) lines.push(`App file: ${context.appFile}`);
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			const projectType = context.projectType;
+			return [
+				`Analyzed your ${projectType ? getFastAPIProjectTypeName(projectType) : "FastAPI"} project structure`,
+				`Installed the PostHog Python package`,
+				`Configured PostHog in your FastAPI application`,
+				`Added PostHog initialization with lifespan event handling`
+			];
+		},
+		getOutroNextSteps: () => [
+			"Start your FastAPI development server to see PostHog in action",
+			"Visit your PostHog dashboard to see incoming events",
+			"Use posthog.identify() to associate events with users"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/laravel/utils.ts
+/**
+* Ignore patterns for Laravel projects
+*/
+const LARAVEL_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/vendor/**",
+	"**/storage/**",
+	"**/bootstrap/cache/**",
+	"**/.phpunit.cache/**",
+	"**/public/build/**",
+	"**/public/hot/**"
+];
+/**
+* Get Laravel version bucket for analytics
+*/
+const getLaravelVersionBucket = createVersionBucket();
+/**
+* Read and parse composer.json
+*/
+function getComposerJson(options) {
+	const { installDir } = options;
+	const composerPath = path$1.join(installDir, "composer.json");
+	try {
+		const content = fs$1.readFileSync(composerPath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return;
+	}
+}
+/**
+* Check if a package is installed (present in composer.json)
+*/
+function hasComposerPackage(packageName, options) {
+	const composer = getComposerJson(options);
+	if (!composer) return false;
+	return !!(composer.require?.[packageName] || composer["require-dev"]?.[packageName]);
+}
+/**
+* Extract version for a package from composer.json
+*/
+function getComposerPackageVersion(packageName, options) {
+	const composer = getComposerJson(options);
+	if (!composer) return void 0;
+	const version = composer.require?.[packageName] || composer["require-dev"]?.[packageName];
+	if (version) return version.replace(/^[\^~>=<]+/, "");
+}
+/**
+* Check if a pattern exists in PHP source files
+*/
+async function hasLaravelCodePattern(pattern, options, filePatterns = ["**/*.php"]) {
+	const { installDir } = options;
+	const phpFiles = await fg(filePatterns, {
+		cwd: installDir,
+		ignore: LARAVEL_IGNORE_PATTERNS
+	});
+	const searchPattern = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+	for (const phpFile of phpFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, phpFile), "utf-8");
+		if (searchPattern.test(content)) return true;
+	} catch {
+		continue;
+	}
+	return false;
+}
+/**
+* Get Laravel version from composer.json
+*/
+function getLaravelVersion(options) {
+	return getComposerPackageVersion("laravel/framework", options);
+}
+/**
+* Get human-readable name for Laravel project type
+*/
+function getLaravelProjectTypeName(projectType) {
+	switch (projectType) {
+		case "standard": return "Standard Laravel";
+		case "inertia": return "Laravel with Inertia.js";
+		case "livewire": return "Laravel with Livewire";
+		default: return "Laravel";
+	}
+}
+/**
+* Check for Inertia.js
+*/
+async function hasInertia(options) {
+	return hasComposerPackage("inertiajs/inertia-laravel", options) || await hasLaravelCodePattern(/Inertia::render|inertia\(/, options);
+}
+/**
+* Check for Livewire
+*/
+async function hasLivewire(options) {
+	return hasComposerPackage("livewire/livewire", options) || await hasLaravelCodePattern(/extends\s+Component|@livewire/, options);
+}
+/**
+* Detect Laravel project type
+*/
+async function getLaravelProjectType(options) {
+	if (await hasInertia(options)) {
+		getUI().setDetectedFramework("Laravel with Inertia.js");
+		return "inertia";
+	}
+	if (await hasLivewire(options)) {
+		getUI().setDetectedFramework("Laravel with Livewire");
+		return "livewire";
+	}
+	getUI().setDetectedFramework("Laravel");
+	return "standard";
+}
+/**
+* Find the main service provider file
+*/
+async function findLaravelServiceProvider(options) {
+	const { installDir } = options;
+	const appServiceProvider = path$1.join(installDir, "app/Providers/AppServiceProvider.php");
+	if (fs$1.existsSync(appServiceProvider)) return "app/Providers/AppServiceProvider.php";
+	return (await fg(["**/app/Providers/*ServiceProvider.php"], {
+		cwd: installDir,
+		ignore: LARAVEL_IGNORE_PATTERNS
+	}))[0];
+}
+/**
+* Find the bootstrap file (differs between Laravel versions)
+*/
+function findLaravelBootstrapFile(options) {
+	const { installDir } = options;
+	const bootstrapApp = path$1.join(installDir, "bootstrap/app.php");
+	if (fs$1.existsSync(bootstrapApp)) return "bootstrap/app.php";
+	const httpKernel = path$1.join(installDir, "app/Http/Kernel.php");
+	if (fs$1.existsSync(httpKernel)) return "app/Http/Kernel.php";
+}
+/**
+* Detect Laravel version structure for configuration guidance
+*/
+function detectLaravelStructure(options) {
+	const version = getLaravelVersion(options);
+	if (!version) return "modern";
+	try {
+		const majorVersion = parseInt(version.split(".")[0], 10);
+		if (majorVersion >= 11) return "latest";
+		if (majorVersion >= 9) return "modern";
+		return "legacy";
+	} catch {
+		return "modern";
+	}
+}
+//#endregion
+//#region src/frameworks/laravel/laravel-wizard-agent.ts
+const LARAVEL_AGENT_CONFIG = {
+	metadata: {
+		name: "Laravel",
+		integration: "laravel",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/php",
+		unsupportedVersionDocsUrl: "https://posthog.com/docs/libraries/php",
+		gatherContext: async (options) => {
+			return {
+				projectType: await getLaravelProjectType(options),
+				serviceProvider: await findLaravelServiceProvider(options),
+				bootstrapFile: findLaravelBootstrapFile(options),
+				laravelStructure: detectLaravelStructure(options)
+			};
+		}
+	},
+	detection: {
+		packageName: "laravel/framework",
+		packageDisplayName: "Laravel",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		getVersionBucket: getLaravelVersionBucket,
+		minimumVersion: "9.0.0",
+		getInstalledVersion: (options) => Promise.resolve(getLaravelVersion(options)),
+		detect: async (options) => {
+			const { installDir } = options;
+			const artisanPath = path$1.join(installDir, "artisan");
+			if (fs$1.existsSync(artisanPath)) try {
+				const content = fs$1.readFileSync(artisanPath, "utf-8");
+				if (content.includes("Laravel") || content.includes("Artisan")) return true;
+			} catch {}
+			const composerPath = path$1.join(installDir, "composer.json");
+			if (fs$1.existsSync(composerPath)) try {
+				const content = fs$1.readFileSync(composerPath, "utf-8");
+				const composer = JSON.parse(content);
+				if (composer.require?.["laravel/framework"] || composer["require-dev"]?.["laravel/framework"]) return true;
+			} catch {}
+			return (await fg(["**/bootstrap/app.php", "**/app/Http/Kernel.php"], {
+				cwd: installDir,
+				ignore: ["**/vendor/**"]
+			})).length > 0;
+		},
+		detectPackageManager: composerPackageManager
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({
+		projectType: context.projectType || "unknown",
+		laravelStructure: context.laravelStructure || "unknown"
+	}) },
+	prompts: {
+		projectTypeDetection: "This is a PHP/Laravel project. Look for composer.json, artisan CLI, and app/ directory structure to confirm. Check for Laravel-specific packages like laravel/framework.",
+		packageInstallation: "Use Composer to install packages. Run `composer require posthog/posthog-php` without pinning a specific version.",
+		getAdditionalContextLines: (context) => {
+			const lines = [
+				`Project type: ${context.projectType ? getLaravelProjectTypeName(context.projectType) : "unknown"}`,
+				`Framework docs ID: php (use posthog://docs/frameworks/php for documentation)`,
+				`Laravel structure: ${context.laravelStructure} (affects where to add configuration)`
+			];
+			if (context.serviceProvider) lines.push(`Service provider: ${context.serviceProvider}`);
+			if (context.bootstrapFile) lines.push(`Bootstrap file: ${context.bootstrapFile}`);
+			if (context.laravelStructure === "latest") lines.push("Note: Laravel 11+ uses simplified bootstrap/app.php for middleware and providers");
+			else lines.push("Note: Use app/Http/Kernel.php for middleware, app/Providers for service providers");
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			const changes = [
+				`Analyzed your ${context.projectType ? getLaravelProjectTypeName(context.projectType) : "Laravel"} project structure`,
+				`Installed the PostHog PHP package via Composer`,
+				`Configured PostHog in your Laravel application`
+			];
+			if (context.laravelStructure === "latest") changes.push("Added PostHog initialization to bootstrap/app.php");
+			else changes.push("Created a PostHog service provider for initialization");
+			if (context.projectType === "inertia") changes.push("Configured PostHog to work with Inertia.js");
+			if (context.projectType === "livewire") changes.push("Configured PostHog to work with Livewire");
+			return changes;
+		},
+		getOutroNextSteps: () => [
+			"Start your Laravel development server with `php artisan serve`",
+			"Visit your PostHog dashboard to see incoming events",
+			"Use PostHog::capture() to track custom events",
+			"Use PostHog::identify() to associate events with users"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/svelte/svelte-wizard-agent.ts
+const SVELTEKIT_AGENT_CONFIG = {
+	metadata: {
+		name: "SvelteKit",
+		integration: "sveltekit",
+		docsUrl: "https://posthog.com/docs/libraries/svelte",
+		beta: true,
+		additionalMcpServers: { svelte: { url: "https://mcp.svelte.dev/mcp" } }
+	},
+	detection: {
+		packageName: "@sveltejs/kit",
+		packageDisplayName: "SvelteKit",
+		getVersion: (packageJson) => getPackageVersion("@sveltejs/kit", packageJson),
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			return packageJson ? hasPackageInstalled("@sveltejs/kit", packageJson) : false;
+		},
+		minimumVersion: "2.0.0",
+		detectPackageManager: detectNodePackageManagers
+	},
+	environment: {
+		uploadToHosting: true,
+		getEnvVars: (apiKey, host) => ({
+			PUBLIC_POSTHOG_PROJECT_TOKEN: apiKey,
+			PUBLIC_POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: () => ({}) },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project using SvelteKit. Look for package.json, svelte.config.js, and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		getAdditionalContextLines: () => ["Framework docs ID: sveltekit (use posthog://docs/frameworks/sveltekit for documentation)"]
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 8,
+		getOutroChanges: () => [
+			"Analyzed your SvelteKit project structure",
+			"Created and configured PostHog initializers",
+			"Integrated PostHog into your application"
+		],
+		getOutroNextSteps: () => ["Start your development server to see PostHog in action", "Visit your PostHog dashboard to see incoming events"]
+	}
+};
+//#endregion
+//#region src/frameworks/swift/utils.ts
+function getSwiftProjectTypeName(projectType) {
+	switch (projectType) {
+		case "swiftui": return "SwiftUI";
+		case "uikit": return "UIKit";
+		case "spm": return "Swift Package";
+	}
+}
+async function detectSwiftProjectType(options) {
+	const { installDir } = options;
+	const hasPackageSwift = fs$1.existsSync(path$1.join(installDir, "Package.swift"));
+	const xcodeProjects = await fg("*.xcodeproj", {
+		cwd: installDir,
+		onlyDirectories: true
+	});
+	if (hasPackageSwift && xcodeProjects.length === 0) return "spm";
+	const swiftFiles = await fg("**/*.swift", {
+		cwd: installDir,
+		ignore: [
+			"**/.build/**",
+			"**/DerivedData/**",
+			"**/build/**",
+			"**/*.xcodeproj/**",
+			"**/Pods/**"
+		]
+	});
+	let hasSwiftUI = false;
+	let hasUIKit = false;
+	for (const file of swiftFiles) try {
+		const content = fs$1.readFileSync(path$1.join(installDir, file), "utf-8");
+		if (content.includes("import SwiftUI")) hasSwiftUI = true;
+		if (content.includes("import UIKit")) hasUIKit = true;
+	} catch {
+		continue;
+	}
+	if (hasSwiftUI) return "swiftui";
+	if (hasUIKit) return "uikit";
+}
+//#endregion
+//#region src/frameworks/swift/swift-wizard-agent.ts
+const SWIFT_AGENT_CONFIG = {
+	metadata: {
+		name: "Swift (iOS/macOS)",
+		integration: "swift",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/ios",
+		preRunNotice: "Please close the Xcode project before proceeding. Xcode may overwrite changes the wizard makes to project files.",
+		gatherContext: async (options) => {
+			return { projectType: await detectSwiftProjectType(options) };
+		}
+	},
+	detection: {
+		packageName: "posthog-ios",
+		packageDisplayName: "Swift",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		detect: async (options) => {
+			const { installDir } = options;
+			if ((await fg("*.xcodeproj", {
+				cwd: installDir,
+				onlyDirectories: true
+			})).length > 0) {
+				if ((await fg("**/*.swift", {
+					cwd: installDir,
+					ignore: [
+						"**/.build/**",
+						"**/DerivedData/**",
+						"**/build/**",
+						"**/*.xcodeproj/**",
+						"**/Pods/**"
+					]
+				})).length > 0) return true;
+			}
+			const packageSwiftPath = path$1.join(installDir, "Package.swift");
+			if (fs$1.existsSync(packageSwiftPath)) return true;
+			return false;
+		},
+		detectPackageManager: swiftPackageManager
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ projectType: context.projectType || "unknown" }) },
+	prompts: {
+		projectTypeDetection: "This is a Swift project. Look for .xcodeproj directories, Package.swift, and .swift source files to confirm. Check for SwiftUI or UIKit imports to determine the UI framework.",
+		packageInstallation: "Add the posthog-ios package via Swift Package Manager. For Xcode projects, add XCRemoteSwiftPackageReference and XCSwiftPackageProductDependency to the .pbxproj file. For Swift packages, add the dependency to Package.swift.",
+		getAdditionalContextLines: (context) => {
+			return [`Project type: ${context.projectType ? getSwiftProjectTypeName(context.projectType) : "unknown"}`, `Framework docs ID: swift (use posthog://docs/frameworks/swift for documentation)`];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your ${context.projectType ? getSwiftProjectTypeName(context.projectType) : "Swift"} project structure`,
+				`Added the PostHog iOS SDK via Swift Package Manager`,
+				`Configured PostHog initialization in your app entry point`,
+				`Added event capture and user identification`
+			];
+		},
+		getOutroNextSteps: () => [
+			"Set POSTHOG_PROJECT_TOKEN and POSTHOG_HOST in your Xcode scheme environment variables",
+			"Build and run your app to see PostHog in action",
+			"Visit your PostHog dashboard to see incoming events"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/android/utils.ts
+const IGNORE_PATTERNS$2 = [
+	"**/build/**",
+	"**/.gradle/**",
+	"**/node_modules/**"
+];
+/**
+* Extract minSdk from the app-level build.gradle(.kts).
+* Returns the value as a semver-like string (e.g. "24" from minSdk = 24).
+*/
+async function getMinSdkVersion(options) {
+	const { installDir } = options;
+	const buildFiles = await fg(["**/build.gradle", "**/build.gradle.kts"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$2
+	});
+	for (const file of buildFiles) try {
+		const match = fs$1.readFileSync(path$1.join(installDir, file), "utf-8").match(/minSdk(?:Version)?\s*=?\s*(\d+)/);
+		if (match) return match[1];
+	} catch {
+		continue;
+	}
+}
+const getKotlinVersionBucket = createVersionBucket();
+/**
+* Read the root or app-level build.gradle(.kts) and extract the Kotlin version.
+*/
+function getKotlinVersion(options) {
+	const { installDir } = options;
+	for (const name of [
+		"build.gradle",
+		"build.gradle.kts",
+		"gradle/libs.versions.toml"
+	]) {
+		const filePath = path$1.join(installDir, name);
+		if (!fs$1.existsSync(filePath)) continue;
+		const content = fs$1.readFileSync(filePath, "utf-8");
+		const match = content.match(/kotlin[_-]?[Vv]ersion\s*=\s*["']([^"']+)["']/);
+		if (match) return match[1];
+		const tomlMatch = content.match(/^kotlin\s*=\s*["']([^"']+)["']/m);
+		if (tomlMatch) return tomlMatch[1];
+	}
+}
+//#endregion
+//#region src/frameworks/android/android-wizard-agent.ts
+const ANDROID_AGENT_CONFIG = {
+	metadata: {
+		name: "Android (Kotlin)",
+		integration: "android",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/android",
+		gatherContext: (options) => {
+			const kotlinVersion = getKotlinVersion(options);
+			return Promise.resolve({ kotlinVersion });
+		}
+	},
+	detection: {
+		packageName: "posthog-android",
+		packageDisplayName: "Android (Kotlin)",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		getVersionBucket: (version) => getKotlinVersionBucket(version),
+		minimumVersion: "21.0.0",
+		getInstalledVersion: (options) => getMinSdkVersion(options),
+		detectPackageManager: gradlePackageManager,
+		detect: async (options) => {
+			const { installDir } = options;
+			for (const name of ["build.gradle", "build.gradle.kts"]) {
+				const buildGradlePath = path$1.join(installDir, name);
+				if (fs$1.existsSync(buildGradlePath)) {
+					const content = fs$1.readFileSync(buildGradlePath, "utf-8");
+					if (content.includes("com.android.application") || content.includes("com.android.library") || content.includes("com.android.tools.build:gradle")) return true;
+				}
+			}
+			if ((await fg("**/AndroidManifest.xml", {
+				cwd: installDir,
+				ignore: [
+					"**/build/**",
+					"**/node_modules/**",
+					"**/.gradle/**"
+				]
+			})).length > 0) {
+				if ((await fg("**/*.kt", {
+					cwd: installDir,
+					ignore: [
+						"**/build/**",
+						"**/node_modules/**",
+						"**/.gradle/**"
+					]
+				})).length > 0) return true;
+			}
+			return false;
+		}
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ ...context.kotlinVersion ? { kotlinVersion: getKotlinVersionBucket(context.kotlinVersion) } : {} }) },
+	prompts: {
+		projectTypeDetection: "This is an Android/Kotlin project. Look for build.gradle or build.gradle.kts files, AndroidManifest.xml, and Kotlin source files (.kt) to confirm.",
+		packageInstallation: "Add the PostHog Android SDK dependency to the app-level build.gradle(.kts) file. Use implementation(\"com.posthog:posthog-android:<VERSION>\"). Check the existing dependency format (Groovy vs Kotlin DSL) and match it.",
+		getAdditionalContextLines: (context) => {
+			const lines = [`Framework docs ID: android (use posthog://docs/frameworks/android for documentation)`];
+			if (context.kotlinVersion) lines.push(`Kotlin version: ${context.kotlinVersion}`);
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: () => [
+			`Analyzed your Android project structure`,
+			`Added the PostHog Android SDK dependency`,
+			`Configured PostHog initialization in your Application class`,
+			`Added event capture and user identification`
+		],
+		getOutroNextSteps: () => [
+			"Build and run your app to see PostHog in action",
+			"Visit your PostHog dashboard to see incoming events",
+			"Check out the PostHog Android docs for advanced features like feature flags and session replay"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/rails/utils.ts
+const IGNORE_PATTERNS$1 = [
+	"**/node_modules/**",
+	"**/vendor/**",
+	"**/vendor/bundle/**",
+	"**/tmp/**",
+	"**/log/**",
+	"**/storage/**"
+];
+/**
+* Get Rails version bucket for analytics
+*/
+const getRailsVersionBucket = createVersionBucket();
+/**
+* Read and parse Gemfile contents
+*/
+function readGemfile(options) {
+	const { installDir } = options;
+	const gemfilePath = path$1.join(installDir, "Gemfile");
+	try {
+		return fs$1.readFileSync(gemfilePath, "utf-8");
+	} catch {
+		return;
+	}
+}
+/**
+* Check if a gem is present in the Gemfile
+*/
+function hasGem(gemName, options) {
+	const content = readGemfile(options);
+	if (!content) return false;
+	return new RegExp(`^\\s*gem\\s+['"]${gemName}['"]`, "im").test(content);
+}
+/**
+* Extract version for a gem from Gemfile
+*/
+function getGemVersion(gemName, options) {
+	const content = readGemfile(options);
+	if (!content) return void 0;
+	const versionPattern = new RegExp(`^\\s*gem\\s+['"]${gemName}['"]\\s*,\\s*['"][^0-9]*([0-9]+\\.[0-9]+(?:\\.[0-9]+)?)['"]`, "im");
+	return content.match(versionPattern)?.[1];
+}
+/**
+* Get Rails version from Gemfile
+*/
+function getRailsVersion(options) {
+	return getGemVersion("rails", options);
+}
+/**
+* Detect Rails project type
+*/
+function getRailsProjectType(options) {
+	const { installDir } = options;
+	const appConfigPath = path$1.join(installDir, "config/application.rb");
+	if (fs$1.existsSync(appConfigPath)) try {
+		if (fs$1.readFileSync(appConfigPath, "utf-8").includes("config.api_only = true")) {
+			getUI().setDetectedFramework("Rails API-only");
+			return "api";
+		}
+	} catch {}
+	getUI().setDetectedFramework("Rails");
+	return "standard";
+}
+/**
+* Get human-readable name for Rails project type
+*/
+function getRailsProjectTypeName(projectType) {
+	switch (projectType) {
+		case "standard": return "Standard Rails";
+		case "api": return "Rails API";
+	}
+}
+/**
+* Find the Rails initializers directory
+*/
+function findInitializersDir(options) {
+	const { installDir } = options;
+	const initializersDir = path$1.join(installDir, "config/initializers");
+	if (fs$1.existsSync(initializersDir)) return "config/initializers";
+}
+/**
+* Detect if the project is a Rails project by looking for typical Rails files
+*/
+async function isRailsProject(options) {
+	const { installDir } = options;
+	const binRailsPath = path$1.join(installDir, "bin/rails");
+	if (fs$1.existsSync(binRailsPath)) return true;
+	const appConfigPath = path$1.join(installDir, "config/application.rb");
+	if (fs$1.existsSync(appConfigPath)) try {
+		const content = fs$1.readFileSync(appConfigPath, "utf-8");
+		if (content.includes("Rails::Application") || content.includes("require \"rails\"") || content.includes("require 'rails'")) return true;
+	} catch {}
+	if (hasGem("rails", options)) return true;
+	return (await fg(["config/routes.rb", "config/environment.rb"], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS$1
+	})).length >= 2;
+}
+//#endregion
+//#region src/frameworks/rails/rails-wizard-agent.ts
+const RAILS_AGENT_CONFIG = {
+	metadata: {
+		name: "Ruby on Rails",
+		integration: "rails",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/ruby-on-rails",
+		unsupportedVersionDocsUrl: "https://posthog.com/docs/libraries/ruby",
+		gatherContext: (options) => {
+			const projectType = getRailsProjectType(options);
+			const initializersDir = findInitializersDir(options);
+			return Promise.resolve({
+				projectType,
+				initializersDir
+			});
+		}
+	},
+	detection: {
+		packageName: "rails",
+		packageDisplayName: "Ruby on Rails",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		getVersionBucket: getRailsVersionBucket,
+		minimumVersion: "6.0.0",
+		getInstalledVersion: (options) => Promise.resolve(getRailsVersion(options)),
+		detect: async (options) => isRailsProject(options),
+		detectPackageManager: bundlerPackageManager
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => ({ projectType: context.projectType || "unknown" }) },
+	prompts: {
+		projectTypeDetection: "This is a Ruby on Rails project. Look for Gemfile, config/application.rb, bin/rails, and config/routes.rb to confirm.",
+		packageInstallation: "Use Bundler to install gems. Add `gem 'posthog-ruby'` and `gem 'posthog-rails'` to the Gemfile and run `bundle install`. Do not pin specific versions.",
+		getAdditionalContextLines: (context) => {
+			const lines = [`Project type: ${context.projectType ? getRailsProjectTypeName(context.projectType) : "unknown"}`, `Framework docs ID: ruby-on-rails (use posthog://docs/frameworks/ruby-on-rails for documentation)`];
+			if (context.initializersDir) lines.push(`Initializers directory: ${context.initializersDir}`);
+			if (context.projectType === "api") lines.push("Note: This is an API-only Rails app — skip frontend posthog-js integration");
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			const changes = [
+				`Analyzed your ${context.projectType ? getRailsProjectTypeName(context.projectType) : "Rails"} project structure`,
+				`Installed the posthog-ruby and posthog-rails gems via Bundler`,
+				`Created PostHog initializer in config/initializers/posthog.rb`,
+				`Configured automatic exception capture and ActiveJob instrumentation`
+			];
+			if (context.projectType !== "api") changes.push("Added posthog-js snippet to the layout template for frontend tracking");
+			return changes;
+		},
+		getOutroNextSteps: () => [
+			"Start your Rails development server with `bin/rails server`",
+			"Visit your PostHog dashboard to see incoming events",
+			"Use PostHog.capture() to track custom events",
+			"Use PostHog.identify() to associate events with users",
+			"Define posthog_distinct_id on your User model for automatic user association"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/python/python-wizard-agent.ts
+const PYTHON_AGENT_CONFIG = {
+	metadata: {
+		name: "Python Language",
+		integration: "python",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/python",
+		gatherContext: async (options) => {
+			return { packageManager: await detectPackageManager$1(options) };
+		}
+	},
+	detection: {
+		packageName: "python",
+		packageDisplayName: "Python",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		getVersionBucket: getPythonVersionBucket,
+		minimumVersion: "3.8.0",
+		getInstalledVersion: (options) => Promise.resolve(getPythonVersion(options)),
+		detect: async (options) => {
+			const { installDir } = options;
+			const pythonConfigFiles = await fg([
+				"**/requirements*.txt",
+				"**/pyproject.toml",
+				"**/setup.py",
+				"**/Pipfile"
+			], {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**"
+				]
+			});
+			if (pythonConfigFiles.length === 0) return false;
+			const managePyMatches = await fg("**/manage.py", {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**"
+				]
+			});
+			for (const match of managePyMatches) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, match), "utf-8");
+				if (content.includes("django") || content.includes("DJANGO_SETTINGS_MODULE")) return false;
+			} catch {
+				continue;
+			}
+			for (const configFile of pythonConfigFiles) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, configFile), "utf-8");
+				if (/^flask([<>=~!]|$|\s)/im.test(content) || /["']flask["']/i.test(content)) return false;
+			} catch {
+				continue;
+			}
+			const pyFiles = await fg([
+				"**/app.py",
+				"**/wsgi.py",
+				"**/application.py",
+				"**/__init__.py"
+			], {
+				cwd: installDir,
+				ignore: [
+					"**/venv/**",
+					"**/.venv/**",
+					"**/env/**",
+					"**/.env/**",
+					"**/__pycache__/**"
+				]
+			});
+			for (const pyFile of pyFiles) try {
+				const content = fs$1.readFileSync(path$1.join(installDir, pyFile), "utf-8");
+				if (content.includes("from flask import") || content.includes("import flask") || /Flask\s*\(/.test(content)) return false;
+			} catch {
+				continue;
+			}
+			return true;
+		},
+		detectPackageManager: detectPythonPackageManagers
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => {
+		return { packageManager: context.packageManager ? getPackageManagerName$1(context.packageManager) : "unknown" };
+	} },
+	prompts: {
+		packageInstallation: PYTHON_PACKAGE_INSTALLATION,
+		projectTypeDetection: "This is a generic Python project. Look for requirements.txt, pyproject.toml, setup.py, or Pipfile to confirm.",
+		getAdditionalContextLines: (context) => {
+			return [
+				`Package manager: ${context.packageManager ? getPackageManagerName$1(context.packageManager) : "unknown"}`,
+				`Framework docs ID: python (use posthog://docs/frameworks/python for documentation)`,
+				`Project type: Generic Python application (CLI, script, worker, data pipeline, etc.)`
+			];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your Python project structure`,
+				`Installed the PostHog Python package using ${context.packageManager ? getPackageManagerName$1(context.packageManager) : "package manager"}`,
+				`Created PostHog initialization using instance-based API (Posthog class)`,
+				`Configured exception autocapture and graceful shutdown`,
+				`Added example code for events, feature flags, and error capture (without PII)`
+			];
+		},
+		getOutroNextSteps: () => [
+			"Use Posthog() class (not module-level posthog) with enable_exception_autocapture=True",
+			"Call posthog_client.shutdown() on application exit (use atexit.register)",
+			"NEVER send PII in event properties (no emails, names, or user content)",
+			"Use posthog_client.capture() for events and posthog_client.identify() for users",
+			"Visit your PostHog dashboard to see incoming events"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/ruby/utils.ts
+const IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/vendor/**",
+	"**/vendor/bundle/**",
+	"**/tmp/**",
+	"**/log/**"
+];
+/**
+* Get Ruby version bucket for analytics
+*/
+const getRubyVersionBucket = createVersionBucket();
+/**
+* Detect Ruby package manager
+*/
+function detectPackageManager(options) {
+	const { installDir } = options;
+	const gemfilePath = path$1.join(installDir, "Gemfile");
+	if (fs$1.existsSync(gemfilePath)) return "bundler";
+	return "manual";
+}
+/**
+* Get human-readable name for package manager
+*/
+function getPackageManagerName(packageManager) {
+	switch (packageManager) {
+		case "bundler": return "Bundler";
+		case "manual": return "gem install";
+	}
+}
+/**
+* Get Ruby version from .ruby-version file or Gemfile
+*/
+function getRubyVersion(options) {
+	const { installDir } = options;
+	const rubyVersionPath = path$1.join(installDir, ".ruby-version");
+	try {
+		const version = fs$1.readFileSync(rubyVersionPath, "utf-8").trim().replace(/^ruby-/, "");
+		if (/^[0-9]+\.[0-9]+/.test(version)) return version;
+	} catch {}
+	const gemfilePath = path$1.join(installDir, "Gemfile");
+	try {
+		const match = fs$1.readFileSync(gemfilePath, "utf-8").match(/ruby\s+['"]([0-9]+\.[0-9]+(?:\.[0-9]+)?)['"]/);
+		if (match) return match[1];
+	} catch {}
+}
+/**
+* Check if the project is a Ruby project (but not Rails)
+*/
+async function isRubyProject(options) {
+	const { installDir } = options;
+	const gemfilePath = path$1.join(installDir, "Gemfile");
+	if (fs$1.existsSync(gemfilePath)) {
+		try {
+			const content = fs$1.readFileSync(gemfilePath, "utf-8");
+			if (/^\s*gem\s+['"]rails['"]/im.test(content)) return false;
+		} catch {}
+		return true;
+	}
+	const rubyVersionPath = path$1.join(installDir, ".ruby-version");
+	if (fs$1.existsSync(rubyVersionPath)) return true;
+	if ((await fg("*.gemspec", {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS
+	})).length > 0) return true;
+	return (await fg([
+		"*.rb",
+		"lib/**/*.rb",
+		"bin/**/*.rb"
+	], {
+		cwd: installDir,
+		ignore: IGNORE_PATTERNS
+	})).length > 0;
+}
+//#endregion
+//#region src/frameworks/ruby/ruby-wizard-agent.ts
+const RUBY_AGENT_CONFIG = {
+	metadata: {
+		name: "Ruby",
+		integration: "ruby",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/ruby",
+		gatherContext: (options) => {
+			const packageManager = detectPackageManager(options);
+			return Promise.resolve({ packageManager });
+		}
+	},
+	detection: {
+		packageName: "ruby",
+		packageDisplayName: "Ruby",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		getVersionBucket: getRubyVersionBucket,
+		minimumVersion: "2.7.0",
+		getInstalledVersion: (options) => Promise.resolve(getRubyVersion(options)),
+		detect: async (options) => isRubyProject(options),
+		detectPackageManager: bundlerPackageManager
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => {
+		return { packageManager: context.packageManager ? getPackageManagerName(context.packageManager) : "unknown" };
+	} },
+	prompts: {
+		projectTypeDetection: "This is a Ruby project. Look for Gemfile, *.gemspec, .ruby-version, or *.rb files to confirm.",
+		packageInstallation: "Use Bundler if a Gemfile is present (add `gem 'posthog-ruby'` and run `bundle install`). Otherwise use `gem install posthog-ruby`. Do not pin a specific version.",
+		getAdditionalContextLines: (context) => {
+			return [
+				`Package manager: ${context.packageManager ? getPackageManagerName(context.packageManager) : "unknown"}`,
+				`Framework docs ID: ruby (use posthog://docs/frameworks/ruby for documentation)`,
+				`Project type: Generic Ruby application (CLI, script, gem, worker, etc.)`,
+				``,
+				`## CRITICAL: Ruby PostHog Best Practices`,
+				``,
+				`### 1. Gem Name vs Require`,
+				`The gem is named posthog-ruby but you require it as 'posthog':`,
+				`  gem 'posthog-ruby'  # in Gemfile`,
+				`  require 'posthog'   # in code (NOT require 'posthog-ruby')`,
+				``,
+				`### 2. Use Instance-Based API (REQUIRED for scripts/CLIs)`,
+				`Use PostHog::Client.new for scripts and standalone applications:`,
+				``,
+				`client = PostHog::Client.new(`,
+				`  api_key: ENV['POSTHOG_PROJECT_TOKEN'],`,
+				`  host: ENV['POSTHOG_HOST'] || 'https://us.i.posthog.com'`,
+				`)`,
+				``,
+				`### 3. MUST Call shutdown Before Exit`,
+				`In scripts and CLIs, you MUST call client.shutdown or events will be lost:`,
+				``,
+				`begin`,
+				`  client.capture(distinct_id: 'user_123', event: 'my_event')`,
+				`ensure`,
+				`  client.shutdown`,
+				`end`,
+				``,
+				`### 4. capture_exception Takes Positional Args`,
+				`client.capture_exception(exception, distinct_id, additional_properties)`,
+				`Do NOT use keyword arguments for capture_exception.`,
+				``,
+				`### 5. NEVER Send PII`,
+				`Do NOT include emails, names, phone numbers, or user content in event properties.`
+			];
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your Ruby project structure`,
+				`Installed the posthog-ruby gem using ${context.packageManager ? getPackageManagerName(context.packageManager) : "package manager"}`,
+				`Created PostHog initialization with instance-based API`,
+				`Configured shutdown handler for proper event flushing`
+			];
+		},
+		getOutroNextSteps: () => [
+			"Use client.capture() for events and client.identify() for users",
+			"Always call client.shutdown() before your application exits",
+			"Visit your PostHog dashboard to see incoming events"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/javascript-node/javascript-node-wizard-agent.ts
+const JAVASCRIPT_NODE_AGENT_CONFIG = {
+	metadata: {
+		name: "Node.js",
+		integration: "javascript_node",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/node"
+	},
+	detection: {
+		packageName: "posthog-node",
+		packageDisplayName: "Node.js",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		detectPackageManager: detectNodePackageManagers,
+		detect: async (options) => {
+			return !!await tryGetPackageJson(options);
+		}
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: () => ({}) },
+	prompts: {
+		projectTypeDetection: "This is a server-side Node.js project. Look for package.json and lockfiles to confirm.",
+		packageInstallation: "Use npm, yarn, pnpm, or bun based on the existing lockfile (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb). Install posthog-node as a regular dependency.",
+		getAdditionalContextLines: () => [`Framework docs ID: javascript_node (use posthog://docs/frameworks/javascript_node for documentation)`]
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: () => [
+			`Analyzed your Node.js project structure`,
+			`Installed the posthog-node package`,
+			`Created PostHog initialization with proper configuration`,
+			`Configured graceful shutdown for event flushing`,
+			`Added example code for events, feature flags, and error capture`
+		],
+		getOutroNextSteps: () => [
+			"Use the PostHog client instance for all tracking calls",
+			"Call posthog.shutdown() on application exit to flush pending events",
+			"NEVER send PII in event properties (no emails, names, or user content)",
+			"Use posthog.capture() for events and posthog.identify() for users",
+			"Visit your PostHog dashboard to see incoming events"
+		]
+	}
+};
+//#endregion
+//#region src/frameworks/javascript-web/utils.ts
+const INDEX_HTML_MAX_DEPTH = 6;
+const INDEX_HTML_IGNORE_DIRS = new Set([
+	"node_modules",
+	".git",
+	".next",
+	"dist",
+	"build",
+	".turbo",
+	".cache"
+]);
+/**
+* Packages that indicate a specific framework integration exists.
+* If any of these are in package.json, we should NOT match as generic JavaScript.
+*
+* When adding a new JS framework integration to the wizard,
+* add its detection package here too.
+*/
+const FRAMEWORK_PACKAGES = [
+	"next",
+	"nuxt",
+	"vue",
+	"react-router",
+	"@tanstack/react-start",
+	"@tanstack/react-router",
+	"react-native",
+	"@angular/core",
+	"astro",
+	"@sveltejs/kit"
+];
+/**
+* Detect the JS package manager for the project by checking lockfiles.
+* Reuses the existing package manager detection infrastructure.
+*/
+function detectJsPackageManager(options) {
+	const detected = detectAllPackageManagers(options);
+	if (detected.length > 0) return detected[0].label;
+	return "unknown";
+}
+/**
+* Detect the bundler used in the project by checking package.json dependencies.
+*/
+function detectBundler(options) {
+	try {
+		const content = fs$1.readFileSync(path$1.join(options.installDir, "package.json"), "utf-8");
+		const pkg = JSON.parse(content);
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (allDeps["vite"]) return "vite";
+		if (allDeps["webpack"]) return "webpack";
+		if (allDeps["esbuild"]) return "esbuild";
+		if (allDeps["parcel"]) return "parcel";
+		if (allDeps["rollup"]) return "rollup";
+		return;
+	} catch {
+		return;
+	}
+}
+/**
+* Heuristic: check if there is an index.html anywhere in the project,
+* ignoring common build and dependency directories.
+*/
+function hasIndexHtml(options) {
+	const root = options.installDir;
+	function search(dir, depth) {
+		if (depth > INDEX_HTML_MAX_DEPTH) return false;
+		const base = path$1.basename(dir);
+		if (INDEX_HTML_IGNORE_DIRS.has(base)) return false;
+		let entries;
+		try {
+			entries = fs$1.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return false;
+		}
+		for (const entry of entries) if (entry.isFile() && entry.name.toLowerCase() === "index.html") return true;
+		for (const entry of entries) if (entry.isDirectory()) {
+			if (search(path$1.join(dir, entry.name), depth + 1)) return true;
+		}
+		return false;
+	}
+	return search(root, 0);
+}
+//#endregion
+//#region src/frameworks/javascript-web/javascript-web-wizard-agent.ts
+const JAVASCRIPT_WEB_AGENT_CONFIG = {
+	metadata: {
+		name: "JavaScript (Web)",
+		integration: "javascript_web",
+		beta: true,
+		docsUrl: "https://posthog.com/docs/libraries/js",
+		gatherContext: (options) => {
+			const packageManagerName = detectJsPackageManager(options);
+			const hasTypeScript = fs$1.existsSync(path$1.join(options.installDir, "tsconfig.json"));
+			const hasBundler = detectBundler(options);
+			return Promise.resolve({
+				packageManagerName,
+				hasTypeScript,
+				hasBundler
+			});
+		}
+	},
+	detection: {
+		packageName: "posthog-js",
+		packageDisplayName: "JavaScript (Web)",
+		usesPackageJson: false,
+		getVersion: () => void 0,
+		detectPackageManager: detectNodePackageManagers,
+		detect: async (options) => {
+			const packageJson = await tryGetPackageJson(options);
+			if (!packageJson) return false;
+			for (const frameworkPkg of FRAMEWORK_PACKAGES) if (hasPackageInstalled(frameworkPkg, packageJson)) return false;
+			const { installDir } = options;
+			const hasIndexHtmlFlag = hasIndexHtml(options);
+			const hasBundler = !!detectBundler(options);
+			if ([
+				"package-lock.json",
+				"yarn.lock",
+				"pnpm-lock.yaml",
+				"bun.lockb",
+				"bun.lock",
+				"deno.lock"
+			].some((lockfile) => fs$1.existsSync(path$1.join(installDir, lockfile))) && (hasIndexHtmlFlag || hasBundler)) return true;
+			return false;
+		}
+	},
+	environment: {
+		uploadToHosting: false,
+		getEnvVars: (apiKey, host) => ({
+			POSTHOG_PROJECT_TOKEN: apiKey,
+			POSTHOG_HOST: host
+		})
+	},
+	analytics: { getTags: (context) => {
+		const tags = { packageManager: context.packageManagerName ?? "unknown" };
+		if (context.hasBundler) tags.bundler = context.hasBundler;
+		return tags;
+	} },
+	prompts: {
+		projectTypeDetection: "This is a JavaScript/TypeScript project. Look for package.json and lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, bun.lockb) to confirm.",
+		packageInstallation: "Look for lockfiles to determine the package manager (npm, yarn, pnpm, bun). Do not manually edit package.json.",
+		getAdditionalContextLines: (context) => {
+			const lines = [
+				`Package manager: ${context.packageManagerName ?? "unknown"}`,
+				`Has TypeScript: ${context.hasTypeScript ? "yes" : "no"}`,
+				`Framework docs ID: js (use posthog://docs/frameworks/js for documentation if available)`,
+				`Project type: Generic JavaScript/TypeScript application (no specific framework detected)`
+			];
+			if (context.hasBundler) lines.unshift(`Bundler: ${context.hasBundler}`);
+			return lines;
+		}
+	},
+	ui: {
+		successMessage: "PostHog integration complete",
+		estimatedDurationMinutes: 5,
+		getOutroChanges: (context) => {
+			return [
+				`Analyzed your JavaScript project structure`,
+				`Installed the posthog-js package using ${context.packageManagerName ?? "package manager"}`,
+				`Created PostHog initialization code`,
+				`Configured autocapture, error tracking, and event capture`
+			];
+		},
+		getOutroNextSteps: () => [
+			"Ensure posthog.init() is called before any capture calls",
+			"Autocapture tracks clicks, form submissions, and pageviews automatically",
+			"Use posthog.capture() for custom events and posthog.identify() for users",
+			"NEVER send PII in event properties (no emails, names, or user content)",
+			"Visit your PostHog dashboard to see incoming events"
+		]
+	}
+};
+//#endregion
+//#region src/lib/registry.ts
+var registry_exports = /* @__PURE__ */ __exportAll({ FRAMEWORK_REGISTRY: () => FRAMEWORK_REGISTRY });
+const FRAMEWORK_REGISTRY = {
+	["nextjs"]: NEXTJS_AGENT_CONFIG,
+	["nuxt"]: NUXT_AGENT_CONFIG,
+	["vue"]: VUE_AGENT_CONFIG,
+	["tanstack-start"]: TANSTACK_START_AGENT_CONFIG,
+	["react-router"]: REACT_ROUTER_AGENT_CONFIG,
+	["tanstack-router"]: TANSTACK_ROUTER_AGENT_CONFIG,
+	["react-native"]: REACT_NATIVE_AGENT_CONFIG,
+	["angular"]: ANGULAR_AGENT_CONFIG,
+	["astro"]: ASTRO_AGENT_CONFIG,
+	["django"]: DJANGO_AGENT_CONFIG,
+	["flask"]: FLASK_AGENT_CONFIG,
+	["fastapi"]: FASTAPI_AGENT_CONFIG,
+	["laravel"]: LARAVEL_AGENT_CONFIG,
+	["sveltekit"]: SVELTEKIT_AGENT_CONFIG,
+	["swift"]: SWIFT_AGENT_CONFIG,
+	["android"]: ANDROID_AGENT_CONFIG,
+	["rails"]: RAILS_AGENT_CONFIG,
+	["python"]: PYTHON_AGENT_CONFIG,
+	["ruby"]: RUBY_AGENT_CONFIG,
+	["javascript_node"]: JAVASCRIPT_NODE_AGENT_CONFIG,
+	["javascript_web"]: JAVASCRIPT_WEB_AGENT_CONFIG
+};
+//#endregion
+export { SPINNER_MESSAGE as i, registry_exports as n, DEFAULT_PACKAGE_INSTALLATION as r, FRAMEWORK_REGISTRY as t };
+
+//# sourceMappingURL=registry-s55_iuJT.js.map