@posthog/wizard 2.79.0 → 2.79.1

package/dist/main-CgKxbwMP.js

@@ -0,0 +1,1396 @@
+import { I as WIZARD_TOOL_NAMES, et as fetchSkillMenu, u as recoverOrphanedSettingsBackups } from "./agent-interface-FkbaBJwz.js";
+import { n as ErrorCodes, t as emitWizardError } from "./emit-BSetXzDV.js";
+import { b as isHeadless, x as regionOption, y as headlessOption } from "./debug-kAHwWGg7.js";
+import { t as VERSION } from "./version-CHhJjz_H.js";
+import { o as initLocalDev, s as localMcpSkillsNotice } from "./local-dev-McsurOC-.js";
+import { $ as getSkillsBaseUrl, k as POSTHOG_DOCS_URL } from "./constants-DHCBSfnx.js";
+import { n as analytics } from "./analytics-DXK1gc12.js";
+import { r as setEntryCommand } from "./telemetry-B7zJdRmA.js";
+import "./errors-C2domSkK.js";
+import { t as LoggingUI } from "./logging-ui-Dza4D0MK.js";
+import { n as setUI, t as getUI } from "./ui-Q6-RvERF.js";
+import { t as isNonInteractiveEnvironment } from "./environment-BATlQxcQ.js";
+import "./agent-BWFhuLgo.js";
+import { h as AUDIT_CHECKS_FILE } from "./yara-hooks-BnxejtXK.js";
+import { A as installOrUpdatePostHogCli, B as webAnalyticsDoctorConfig, D as CLI_STEERING_TARGETS, E as errorTrackingUploadSourceMapsConfig, G as createSkillProgram, H as getKindMeta, K as warehouseSourceConfig, O as detectTargets, S as errorTrackingConfig, T as replayVisionConfig, U as fetchHealthIssues, V as posthogDoctorConfig, W as auditConfig, d as metricsConfig, f as aiObservabilityConfig, j as installSteeringSnippet, k as findTarget, m as selfDrivingConfig, o as Program, p as mcpAnalyticsConfig, q as revenueAnalyticsConfig, rt as Colors, s as agentSkillConfig, z as migrationConfig } from "./mint-failure-u8xQKNOn.js";
+import { i as runWizard, n as runWizardCI, t as runWizardHeadless } from "./runners-ov3EXF1n.js";
+import { t as PickerMenu } from "./PickerMenu-dG5DQCZA.js";
+import { t as readApiKeyFromEnv } from "./env-api-key-BP-NFFXt.js";
+import { Agent, setGlobalDispatcher } from "undici";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import * as path$1 from "node:path";
+import { Box, Text, render } from "ink";
+import { createElement } from "react";
+import * as readline from "node:readline/promises";
+//#region src/commands/command.ts
+/** Extract the bare command word(s) from a yargs name spec, dropping positionals and aliases' arg syntax. */
+function commandKeys(name) {
+	return (typeof name === "string" ? [name] : name).map((n) => n.trim().split(/\s+/)[0]);
+}
+function toCommandModule(cmd, parentPath) {
+	const entryCommand = [...parentPath, commandKeys(cmd.name)[0]].filter((key) => key !== "$0").join("-");
+	return {
+		command: cmd.name,
+		describe: cmd.description,
+		builder: (y) => {
+			let next = cmd.options ? y.options(cmd.options) : y;
+			for (const [key, opts] of Object.entries(cmd.positionals ?? {})) next = next.positional(key, opts);
+			if (cmd.check) next = next.check(cmd.check);
+			for (const [usage, description] of cmd.examples ?? []) next = next.example(usage, description);
+			const ownPath = [...parentPath, commandKeys(cmd.name)[0]];
+			for (const child of cmd.children ?? []) next = next.command(toCommandModule(child, ownPath));
+			if (cmd.children?.length && !cmd.handler && !cmd.interactiveDefault) next = next.demandCommand(1);
+			return next;
+		},
+		handler: (argv) => {
+			if (entryCommand) setEntryCommand(entryCommand);
+			(cmd.handler ?? cmd.interactiveDefault ?? (() => void 0))(argv);
+		}
+	};
+}
+//#endregion
+//#region src/wizard.ts
+/**
+* Global yargs options applied to every command. These are read from the
+* `POSTHOG_WIZARD` env prefix as well as flags.
+*
+* Options with `hidden: true` are "internal modes" — they don't show up in
+* `--help` but are still accepted on every command. The `--local-*` flags live
+* in the constructor's `!IS_PRODUCTION_BUILD` block instead, so published
+* builds reject them; see `docs/local-dev.md`.
+*/
+const GLOBAL_OPTIONS = {
+	debug: {
+		default: false,
+		describe: "Enable verbose logging\nenv: POSTHOG_WIZARD_DEBUG",
+		type: "boolean"
+	},
+	signup: {
+		default: false,
+		describe: "Create a new PostHog account during setup\nenv: POSTHOG_WIZARD_SIGNUP",
+		type: "boolean"
+	},
+	telemetry: {
+		default: true,
+		describe: "Send wizard run state to PostHog (pass --no-telemetry to disable)\nenv: POSTHOG_WIZARD_TELEMETRY",
+		type: "boolean"
+	},
+	"api-key": {
+		describe: "PostHog personal API key (phx_xxx) for authentication\nenv: POSTHOG_WIZARD_API_KEY",
+		type: "string"
+	},
+	"project-id": {
+		describe: "PostHog project ID to use (optional; when not set, uses default from API key or OAuth)\nenv: POSTHOG_WIZARD_PROJECT_ID",
+		type: "string"
+	},
+	email: {
+		describe: "Email address for signup (used with --signup)\nenv: POSTHOG_WIZARD_EMAIL",
+		type: "string"
+	},
+	"base-url": {
+		describe: "Override the PostHog base URL (e.g. http://localhost:8010), bypassing region resolution. Pins the API host, cloud URL, and OAuth server.\nenv: POSTHOG_WIZARD_BASE_URL",
+		type: "string",
+		hidden: true
+	},
+	"run-id": {
+		describe: "Assigned cloud WizardRun UUID",
+		type: "string",
+		hidden: true
+	},
+	benchmark: {
+		default: false,
+		describe: "Run in benchmark mode with per-phase token tracking\nenv: POSTHOG_WIZARD_BENCHMARK",
+		type: "boolean",
+		hidden: true
+	},
+	"yara-report": {
+		default: false,
+		describe: "Print YARA scanner summary after the agent run\nenv: POSTHOG_WIZARD_YARA_REPORT",
+		type: "boolean",
+		hidden: true
+	}
+};
+var Wizard = class Wizard {
+	cli;
+	constructor() {
+		let cli = yargs(hideBin(process.argv)).env("POSTHOG_WIZARD").options(GLOBAL_OPTIONS);
+		this.cli = cli.middleware((argv) => {
+			initLocalDev(argv);
+			const notice = localMcpSkillsNotice({
+				localDev: argv.localDev,
+				localMcp: argv.localMcp,
+				localContextMill: argv.localContextMill
+			});
+			if (notice) process.stderr.write(`\n\x1b[33m! ${notice}\x1b[0m\n\n`);
+		}).strictOptions().strictCommands().fail((msg, err) => {
+			const text = msg || err && err.message || "Invalid arguments";
+			process.stderr.write(`\n\x1b[1;91m✖ ${text}\x1b[0m\n  Run \`wizard --help\` to see available commands and options.\n\n`);
+			emitWizardError({
+				code: ErrorCodes.CliBadArgs,
+				message: text
+			});
+			process.exit(1);
+		}).help().alias("help", "h").version().alias("version", "v");
+	}
+	/** Start a chain; equivalent to `new Wizard().use(...cmds)`. */
+	static use(...cmds) {
+		return new Wizard().use(...cmds);
+	}
+	/** Register one or more commands with yargs. */
+	use(...cmds) {
+		for (const cmd of cmds) this.cli = this.cli.command(toCommandModule(cmd, []));
+		return this;
+	}
+	/** Parse argv and dispatch to the matching registered command. */
+	init() {
+		{
+			const args = process.argv.slice(2);
+			const argvHasCI = args.some((a) => a === "--ci" || a === "--no-ci" || a.startsWith("--ci="));
+			const envHasCI = process.env.POSTHOG_WIZARD_CI != null && process.env.POSTHOG_WIZARD_CI !== "";
+			if (argvHasCI || envHasCI) {
+				process.stderr.write(`\n\x1b[1;91m✖ CI mode is not currently supported in published builds.\x1b[0m\n\n`);
+				emitWizardError({
+					code: ErrorCodes.CliFlagUnavailable,
+					message: "CI mode is not supported in published builds."
+				});
+				process.exit(1);
+			}
+			const argvHasOverride = args.some((a) => a === "--harness" || a.startsWith("--harness=") || a === "--sequence" || a.startsWith("--sequence=") || a === "--model" || a.startsWith("--model=") || a === "--capture-aio" || a === "--no-capture-aio" || a.startsWith("--capture-aio="));
+			const envHasOverride = process.env.POSTHOG_WIZARD_HARNESS != null && process.env.POSTHOG_WIZARD_HARNESS !== "" || process.env.POSTHOG_WIZARD_SEQUENCE != null && process.env.POSTHOG_WIZARD_SEQUENCE !== "" || process.env.POSTHOG_WIZARD_MODEL != null && process.env.POSTHOG_WIZARD_MODEL !== "" || process.env.POSTHOG_WIZARD_CAPTURE_AIO != null && process.env.POSTHOG_WIZARD_CAPTURE_AIO !== "";
+			if (argvHasOverride || envHasOverride) {
+				process.stderr.write(`\n\x1b[1;91m✖ The --harness, --sequence, --model, and --capture-aio overrides are not available in published builds.\x1b[0m\n\n`);
+				emitWizardError({
+					code: ErrorCodes.CliFlagUnavailable,
+					message: "The --harness, --sequence, --model, and --capture-aio overrides are not available in published builds."
+				});
+				process.exit(1);
+			}
+			const argvHasLocalTarget = args.some((a) => LOCAL_TARGET_FLAGS.some((f) => a === `--${f}` || a === `--no-${f}` || a.startsWith(`--${f}=`)));
+			const envHasLocalTarget = LOCAL_TARGET_ENV_VARS.some((k) => process.env[k] != null && process.env[k] !== "");
+			if (argvHasLocalTarget || envHasLocalTarget) {
+				process.stderr.write("\n\x1B[1;91m✖ The --local-dev, --local-context-mill, --local-mcp, and --local-posthog targets are not available in published builds.\x1B[0m\n  They point the wizard at development servers on localhost.\n\n");
+				emitWizardError({
+					code: ErrorCodes.CliFlagUnavailable,
+					message: "The --local-dev, --local-context-mill, --local-mcp, and --local-posthog targets are not available in published builds."
+				});
+				process.exit(1);
+			}
+		}
+		this.cli.wrap(process.stdout.isTTY ? this.cli.terminalWidth() : 80).argv;
+	}
+};
+/** Excludes bare `local`: `wizard mcp add --local` stays available in prod. */
+const LOCAL_TARGET_FLAGS = [
+	"local-dev",
+	"local-context-mill",
+	"local-mcp",
+	"local-posthog"
+];
+const LOCAL_TARGET_ENV_VARS = [
+	"POSTHOG_WIZARD_LOCAL_DEV",
+	"POSTHOG_WIZARD_LOCAL_CONTEXT_MILL",
+	"POSTHOG_WIZARD_LOCAL_MCP",
+	"POSTHOG_WIZARD_LOCAL_POSTHOG"
+];
+//#endregion
+//#region src/commands/provision.ts
+const provisionCommand = {
+	name: "provision",
+	description: "Create a new PostHog account (headless, no TUI)",
+	options: {
+		email: {
+			describe: "Email address for the new account",
+			type: "string",
+			demandOption: true
+		},
+		region: {
+			describe: "Cloud region (us or eu)",
+			choices: ["us", "eu"],
+			default: "us"
+		},
+		name: {
+			describe: "Name for the new account",
+			type: "string",
+			default: ""
+		},
+		json: {
+			describe: "Emit JSON result to stdout (defaults to true when stdout is not a TTY)",
+			type: "boolean"
+		}
+	},
+	examples: [["wizard provision --email matt+test@posthog.com --region us", ""], ["wizard provision --email user@example.com --region eu --json", ""]],
+	handler: runProvision
+};
+function runProvision(argv) {
+	const jsonMode = argv.json === void 0 ? !process.stdout.isTTY : Boolean(argv.json);
+	if (!jsonMode) setUI(new LoggingUI());
+	provision({
+		email: argv.email,
+		region: argv.region.toUpperCase(),
+		name: argv.name ?? "",
+		baseUrl: argv.baseUrl,
+		jsonMode
+	});
+}
+async function provision({ email, region, name, baseUrl, jsonMode }) {
+	try {
+		const { provisionNewAccount } = await import("./provisioning-OGFGlzf7.js");
+		if (!jsonMode) getUI().log.info(`Provisioning account for ${email} in ${region}...`);
+		emitResult(await provisionNewAccount(email, name, region, { baseUrl }), jsonMode);
+		process.exit(0);
+	} catch (error) {
+		emitError(error, jsonMode);
+		process.exit(1);
+	}
+}
+function emitResult(result, jsonMode) {
+	if (jsonMode) {
+		process.stdout.write(`${JSON.stringify(result)}\n`);
+		return;
+	}
+	getUI().log.success("Account provisioned successfully:");
+	getUI().log.info(`  API Key:       ${result.projectApiKey}`);
+	getUI().log.info(`  Host:          ${result.host}`);
+	getUI().log.info(`  Project ID:    ${result.projectId}`);
+	getUI().log.info(`  Account ID:    ${result.accountId}`);
+	getUI().log.info(`  Access Token:  ${result.accessToken}`);
+	getUI().log.info(`  Refresh Token: ${result.refreshToken}`);
+	if (result.personalApiKey) getUI().log.info(`  Personal API Key: ${result.personalApiKey}`);
+}
+function emitError(error, jsonMode) {
+	const msg = error instanceof Error ? error.message : String(error);
+	const code = msg.includes("already associated") ? "email_exists" : "provisioning_failed";
+	if (jsonMode) {
+		process.stderr.write(`${JSON.stringify({
+			error: msg,
+			code
+		})}\n`);
+		return;
+	}
+	getUI().log.error(`Provisioning failed: ${msg}`);
+}
+//#endregion
+//#region src/commands/basic-integration/index.ts
+const basicIntegrationCommand = {
+	name: ["$0"],
+	description: "Run the PostHog setup wizard",
+	children: [provisionCommand],
+	options: {
+		"install-dir": {
+			describe: "Directory to install PostHog in\nenv: POSTHOG_WIZARD_INSTALL_DIR",
+			type: "string"
+		},
+		name: {
+			describe: "Name for account creation with --ci --signup\nenv: POSTHOG_WIZARD_NAME",
+			type: "string"
+		},
+		playground: {
+			default: false,
+			describe: "Launch the TUI primitives playground",
+			type: "boolean",
+			hidden: true
+		},
+		...headlessOption,
+		...regionOption
+	},
+	check: (argv) => {
+		if (argv.playground && (argv.ci || isHeadless(argv))) throw new Error("--playground cannot be combined with a headless run.");
+		return true;
+	},
+	handler: (argv) => {
+		setEntryCommand("integrate");
+		(async () => {
+			if (isHeadless(argv)) {
+				const { runHeadlessInstall } = await import("./ci-install-COcV8SY2.js");
+				return runHeadlessInstall(argv);
+			}
+			if (argv.ci) {
+				const { runCIInstall } = await import("./ci-install-COcV8SY2.js");
+				return runCIInstall(argv);
+			}
+			if (isNonInteractiveEnvironment()) {
+				const { failNonInteractive } = await import("./non-interactive-DyVC1AGc.js");
+				return failNonInteractive();
+			}
+			if (argv.playground) {
+				const { runPlayground } = await import("./playground-BlYRBMj7.js");
+				return runPlayground();
+			}
+			const { runInteractive } = await import("./interactive-B_Ti_CsS.js");
+			runInteractive(argv);
+		})();
+	}
+};
+//#endregion
+//#region src/commands/mcp/tui-availability.ts
+/**
+* startTUI throws CliInteractiveRequired, and Ink throws "Raw mode is not
+* supported", when stdin has no TTY (piped input, CI, some IDE terminals).
+* That is the only TUI failure the mcp commands
+* degrade to LoggingUI for — any other error from the TUI path is a real bug
+* and must surface rather than be silently swallowed.
+*/
+function isTUIUnavailable(error) {
+	if (!(error instanceof Error)) return false;
+	return error.code === ErrorCodes.CliInteractiveRequired || /raw mode is not supported/i.test(error.message);
+}
+//#endregion
+//#region src/commands/mcp/add.ts
+const mcpAddCommand = {
+	name: "add",
+	description: "Install PostHog MCP server to supported clients",
+	options: {
+		local: {
+			default: false,
+			describe: "Add local development MCP server (http://localhost:8787)",
+			type: "boolean"
+		},
+		features: {
+			describe: "Comma-separated list of features to enable (default: all)",
+			type: "string"
+		},
+		"api-key": {
+			describe: "PostHog personal API key (phx_xxx) for MCP authentication",
+			type: "string"
+		},
+		...headlessOption
+	},
+	handler: runMcpAdd
+};
+function runMcpAdd(argv) {
+	const features = parseFeatures(argv.features);
+	(async () => {
+		const { readApiKeyFromEnv } = await import("./env-api-key-CaWEDj_9.js");
+		const apiKey = argv.apiKey || readApiKeyFromEnv();
+		const debug = argv.debug;
+		const localMcp = argv.local;
+		const args = {
+			local: localMcp,
+			features,
+			apiKey
+		};
+		if (isHeadless(argv)) {
+			await runHeadlessAdd(args);
+			return;
+		}
+		try {
+			const { startTUI } = await import("./start-tui-Bo2L0bar.js");
+			const { buildSession } = await import("./wizard-session-DGaUHOF3.js");
+			const tui = startTUI(VERSION, Program.McpAdd);
+			tui.store.session = buildSession({
+				debug,
+				localMcp,
+				mcpFeatures: features,
+				apiKey,
+				baseUrl: argv.baseUrl
+			});
+		} catch (error) {
+			if (!isTUIUnavailable(error)) throw error;
+			await runHeadlessAdd(args);
+		}
+	})();
+}
+async function runHeadlessAdd(args) {
+	setUI(new LoggingUI());
+	const { addMCPServerToClientsStep } = await import("./add-mcp-server-to-clients-artmN7mz.js");
+	const { installed, failed } = await addMCPServerToClientsStep(args);
+	if (failed.length > 0 || installed.length === 0) process.exitCode = 1;
+}
+function parseFeatures(raw) {
+	if (typeof raw !== "string") return void 0;
+	return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+//#endregion
+//#region src/commands/mcp/remove.ts
+const mcpRemoveCommand = {
+	name: "remove",
+	description: "Remove PostHog MCP server from supported clients",
+	options: {
+		local: {
+			default: false,
+			describe: "Remove local development MCP server (http://localhost:8787)",
+			type: "boolean"
+		},
+		...headlessOption
+	},
+	handler: runMcpRemove
+};
+function runMcpRemove(argv) {
+	(async () => {
+		const debug = argv.debug;
+		const localMcp = argv.local;
+		if (isHeadless(argv)) {
+			await runHeadlessRemove(localMcp);
+			return;
+		}
+		try {
+			const { startTUI } = await import("./start-tui-Bo2L0bar.js");
+			const { buildSession } = await import("./wizard-session-DGaUHOF3.js");
+			const tui = startTUI(VERSION, Program.McpRemove);
+			tui.store.session = buildSession({
+				debug,
+				localMcp,
+				baseUrl: argv.baseUrl
+			});
+		} catch (error) {
+			if (!isTUIUnavailable(error)) throw error;
+			await runHeadlessRemove(localMcp);
+		}
+	})();
+}
+/** No exit code on an empty result: nothing to remove is the requested end state. */
+async function runHeadlessRemove(local) {
+	setUI(new LoggingUI());
+	const { removeMCPServerFromClientsStep } = await import("./add-mcp-server-to-clients-artmN7mz.js");
+	await removeMCPServerFromClientsStep({ local });
+}
+//#endregion
+//#region src/commands/mcp/tutorial.ts
+const mcpTutorialCommand = {
+	name: "tutorial",
+	description: "Try the PostHog MCP with your agent (no install needed)",
+	options: { local: {
+		default: false,
+		describe: "Point the tutorial at the local MCP server (http://localhost:8787)",
+		type: "boolean"
+	} },
+	handler: runMcpTutorial
+};
+function runMcpTutorial(argv) {
+	(async () => {
+		const debug = argv.debug;
+		const localMcp = argv.local;
+		try {
+			const { startTUI } = await import("./start-tui-Bo2L0bar.js");
+			const { buildSession } = await import("./wizard-session-DGaUHOF3.js");
+			const tui = startTUI(VERSION, Program.McpTutorial);
+			tui.store.session = buildSession({
+				debug,
+				localMcp,
+				baseUrl: argv.baseUrl
+			});
+		} catch (err) {
+			setUI(new LoggingUI());
+			getUI().log.error(`The MCP tutorial requires an interactive terminal. ${err instanceof Error ? err.message : String(err)}`);
+			emitWizardError({
+				code: ErrorCodes.CliInteractiveRequired,
+				message: "The MCP tutorial requires an interactive terminal."
+			});
+			process.exit(1);
+		}
+	})();
+}
+//#endregion
+//#region src/commands/mcp/index.ts
+const mcpCommand = {
+	name: "mcp",
+	description: "MCP server management commands",
+	children: [
+		mcpAddCommand,
+		mcpRemoveCommand,
+		mcpTutorialCommand
+	]
+};
+//#endregion
+//#region src/commands/skill-program-options.ts
+/**
+* Per-command options shared by every skill-based program command
+* (`audit events`, `migrate statsig`, `revenue`, `source-maps`, …).
+*
+* Only flags unique to skill commands live here. Global flags are declared
+* once in `wizard.ts` — both in `GLOBAL_OPTIONS` and, for the dev-only ones,
+* the `Wizard` constructor — and apply to every command automatically.
+*/
+const skillProgramOptions = { "install-dir": {
+	describe: "Directory to install in",
+	type: "string"
+} };
+//#endregion
+//#region src/commands/factories/shared.ts
+/**
+* Dispatch a parsed yargs invocation to the wizard runner. Applies the
+* program's `mapCliOptions` transform, then routes to `runWizardHeadless`,
+* `runWizardCI`, or `runWizard` based on the headless / `--ci` flags.
+*
+* Every command file used to inline this; the factories call it instead.
+*/
+/**
+* Run a command's async body as fire-and-forget while still surfacing failures.
+* yargs handlers are synchronous, so async work kicks off a detached promise —
+* without this, a rejection becomes an unhandled promise rejection (no message,
+* wrong exit code). This awaits the work and turns any error into a clean
+* message + non-zero exit.
+*/
+function runCommandHandler(work) {
+	(async () => {
+		try {
+			await work();
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`\n\x1b[1;91m✖ ${msg}\x1b[0m\n\n`);
+			emitWizardError({
+				code: ErrorCodes.InternalUnhandled,
+				message: msg
+			});
+			process.exit(1);
+		}
+	})();
+}
+function dispatchProgram(config, argv) {
+	const argvRecord = { ...argv };
+	const extras = config.mapCliOptions?.(argvRecord) ?? {};
+	const options = {
+		...argvRecord,
+		...extras
+	};
+	if (isHeadless(options)) runWizardHeadless(config, options);
+	else if (options.ci) runWizardCI(config, options);
+	else runWizard(config, options);
+}
+/**
+* Merge the standard skill-program flags (`--debug`, `--install-dir`, etc.)
+* with any program-specific options declared on `cliOptions`.
+*
+* Program-specific options shadow the standard ones — that's intentional, so
+* a program can override a default flag if it ever needs to.
+*/
+function mergeCommandOptions(config) {
+	return {
+		...skillProgramOptions,
+		...config.cliOptions ?? {}
+	};
+}
+//#endregion
+//#region src/commands/factories/native-command-factory.ts
+/**
+* Build a yargs `Command` from a wizard-native `ProgramConfig`.
+*
+* Collapses the previously duplicated boilerplate (read `config.command`,
+* merge skill-program flags with program-specific options, dispatch via
+* `runWizard` / `runWizardCI`) into a single call.
+*/
+function nativeCommandFactory(config, opts = {}) {
+	if (!config.command) throw new Error(`nativeCommandFactory: program "${config.id}" has no \`command\` — wizard-native programs must declare a CLI name`);
+	return {
+		name: config.command,
+		description: config.description,
+		options: mergeCommandOptions(config),
+		children: opts.children,
+		handler: (argv) => dispatchProgram(config, argv)
+	};
+}
+//#endregion
+//#region src/commands/mcp-analytics.ts
+/**
+* `wizard mcp-analytics` — flat skill command, instrument-an-MCP-server today.
+*
+* Distinct from `wizard mcp add`: this instruments the user's own MCP server
+* with the `@posthog/mcp` SDK, rather than installing the PostHog MCP server
+* into a coding agent. Stays flat while instrumenting is the only action.
+*/
+const mcpAnalyticsCommand = nativeCommandFactory(mcpAnalyticsConfig);
+//#endregion
+//#region src/commands/replay-vision.ts
+/**
+* `wizard replay-vision` — flat skill command, set up Replay vision today.
+*
+* Enables session replay recording and creates vision scanners tailored to
+* the product's key flows. Runs the `replay-vision` orchestrator flow, which
+* reuses the integration-v2 install/init mini-agents when the repo has no
+* PostHog integration yet.
+*/
+const replayVisionCommand = nativeCommandFactory(replayVisionConfig);
+//#endregion
+//#region src/commands/ai-observability.ts
+/**
+* `wizard ai-observability` — flat skill command, wire AI Observability into a
+* project today.
+*
+* Installs the OpenTelemetry SDK, the PostHog span processor, and the
+* provider-specific instrumentation so LLM calls emit `$ai_generation` events.
+* The `ai-observability` context-mill skill has one variant per (LLM provider ×
+* language); the agent picks the right one at run time by scanning the
+* project's manifest and (when ambiguous) asking the user via `wizard_ask`.
+* Stays flat while a single "add AIO to a project" flow is the only action.
+*/
+const aiObservabilityCommand = nativeCommandFactory(aiObservabilityConfig);
+//#endregion
+//#region src/commands/metrics.ts
+/**
+* `wizard metrics` — flat skill command, wire PostHog application metrics
+* (counters, gauges, histograms via \`posthog.metrics\`) into a project.
+*
+* The `metrics` context-mill skill has one variant per platform (python,
+* nodejs, javascript, kubernetes, other/OTLP); the agent picks the right one
+* at run time by scanning the project's manifest and (when ambiguous) asking
+* the user via `wizard_ask`. Stays flat while a single "add metrics to a
+* project" flow is the only action.
+*/
+const metricsCommand = nativeCommandFactory(metricsConfig);
+//#endregion
+//#region src/programs/dispatch-family.ts
+/**
+* Capture a CLI dispatch error, flush analytics, and exit. The wizard never
+* starts a run from these paths — use flush() (not shutdown()) so we don't
+* fire a "setup wizard finished" event for a parse error that didn't run.
+*/
+async function exitDispatchError(reason, properties, message, code = 1) {
+	analytics.wizardCapture("cli dispatch error", {
+		reason,
+		...properties
+	});
+	try {
+		await analytics.flush();
+	} catch {}
+	process.stderr.write(message);
+	emitWizardError({
+		code: ErrorCodes.CliBadArgs,
+		message: reason
+	});
+	return process.exit(code);
+}
+/**
+* Family commands (`wizard audit`, `wizard migrate`, ...) resolve their
+* subcommands at runtime against the published `cliEntries` inside
+* `skill-menu.json`. Adding a subcommand is a context-mill release — no
+* wizard release needed.
+*
+* Wizard-native subcommands (programs that aren't backed by a single skill,
+* e.g. `wizard audit web-analytics`) live here in code, dispatched directly
+* without touching the registry. Adding a native is a wizard PR.
+*/
+/** Wizard-native subcommands keyed by family. */
+const NATIVE_HANDLERS = { audit: { "web-analytics": webAnalyticsDoctorConfig } };
+/**
+* Resolve a fetched CliEntry to the ProgramConfig that actually runs it.
+* Most entries run via the generic agent-skill program with the entry's
+* `skillId` injected. The comprehensive `audit all` is the one exception —
+* skillId 'audit' triggers the specialized auditConfig (custom hooks,
+* content blocks, screens).
+*
+* This is the one place that knows a subcommand belongs to `audit`, so the
+* generic skill program picks up the ledger here rather than for every skill.
+*/
+function configForCliEntry(entry, family) {
+	if (entry.skillId === "audit") return auditConfig;
+	return {
+		...agentSkillConfig,
+		skillId: entry.skillId,
+		...family === "audit" ? {
+			auditLedgerFile: AUDIT_CHECKS_FILE,
+			streamWorkflowId: family,
+			allowedTools: [
+				...agentSkillConfig.allowedTools ?? [],
+				WIZARD_TOOL_NAMES.auditSeedChecks,
+				WIZARD_TOOL_NAMES.auditAddChecks,
+				WIZARD_TOOL_NAMES.auditResolveChecks
+			]
+		} : {}
+	};
+}
+function familyEntries(family, entries) {
+	return entries.filter((e) => e.role === "command" && e.parentCommand === family && Boolean(e.command));
+}
+/**
+* Dispatch `wizard <family> <sub>` to the right program.
+*
+* Order:
+*   1. Native handler for (family, sub) — runs immediately, no network.
+*   2. Fetched CliEntry — runs the resolved skill.
+*   3. Unknown — prints the available list and exits non-zero.
+*/
+async function dispatchFamily(family, argv) {
+	const sub = argv.skill?.trim();
+	if (!sub) return exitDispatchError("missing subcommand", { family }, `\n\x1b[1;91m✖ \`wizard ${family}\` requires a subcommand.\x1b[0m\n  Pass one (e.g. \`wizard ${family} <subcommand>\`), or run it in an interactive terminal to pick from a menu.\n\n`);
+	const native = NATIVE_HANDLERS[family]?.[sub];
+	if (native) {
+		dispatchProgram(native, argv);
+		return;
+	}
+	const skillsBaseUrl = getSkillsBaseUrl();
+	const menu = await fetchSkillMenu(skillsBaseUrl);
+	if (!menu) return exitDispatchError("registry unreachable", {
+		family,
+		sub,
+		skillsBaseUrl
+	}, `\n\x1b[1;91m✖ Couldn't reach the skill registry at ${skillsBaseUrl}.\x1b[0m\n  Check your network connection and try again.\n\n`);
+	const entries = menu.cliEntries ?? [];
+	const entry = familyEntries(family, entries).find((e) => e.command === sub);
+	if (entry) {
+		dispatchProgram(configForCliEntry(entry, family), argv);
+		return;
+	}
+	const available = [...Object.keys(NATIVE_HANDLERS[family] ?? {}), ...familyEntries(family, entries).map((e) => e.command)].sort();
+	return exitDispatchError("unknown subcommand", {
+		family,
+		sub,
+		available
+	}, `\n\x1b[1;91m✖ Unknown subcommand "${sub}" under \`${family}\`.\x1b[0m\n` + (available.length ? `  Available: ${available.join(", ")}\n\n` : `  No subcommands published for "${family}" yet.\n\n`));
+}
+/**
+* Build the children list shown in the family's interactive picker.
+* Combines native handlers with skill-backed entries from the live registry.
+* Used by `familyCommandFactory`'s `interactiveDefault`.
+*/
+function buildFamilyPickerChildren(family, entries) {
+	const natives = Object.entries(NATIVE_HANDLERS[family] ?? {}).map(([cmd, program]) => ({
+		name: cmd,
+		description: program.description,
+		handler: (argv) => dispatchProgram(program, argv)
+	}));
+	const live = familyEntries(family, entries).map((entry) => ({
+		name: entry.command,
+		description: entry.description,
+		handler: (argv) => {
+			dispatchFamily(family, {
+				...argv,
+				skill: entry.command
+			});
+		},
+		default: entry.default
+	}));
+	return [...natives, ...live];
+}
+/**
+* The children the family picker shows **today**: only the leaf marked
+* `default` (e.g. `audit events`). Every other subcommand stays runnable
+* directly (`wizard audit <name>`) — they just aren't listed in the picker yet.
+* Falls back to all children when nothing is marked `default`.
+*
+* Temporary: when we're ready to surface the full menu, return `children`
+* unchanged (and delete this note).
+*/
+function pickerChildrenToShow(children) {
+	const defaults = children.filter((c) => c.default);
+	return defaults.length > 0 ? [...defaults] : [...children];
+}
+//#endregion
+//#region src/commands/factories/family-picker.tsx
+function FamilyPickerApp(props) {
+	return createElement(Box, {
+		flexDirection: "column",
+		paddingX: 1,
+		paddingY: 1
+	}, createElement(Text, {
+		bold: true,
+		color: Colors.accent
+	}, props.parentLabel), createElement(Box, { height: 1 }), createElement(PickerMenu, {
+		message: "Pick a subcommand",
+		options: props.options,
+		optionMarginBottom: 1,
+		onSelect: (value) => {
+			const cmd = Array.isArray(value) ? value[0] : value;
+			if (cmd) props.onSelect(cmd);
+		}
+	}));
+}
+function describe(child) {
+	return commandKeys(child.name)[0] ?? "";
+}
+/**
+* Reorder children so the `default`-marked entry is first, while
+* preserving the relative order of the rest. The picker's initial
+* focus is index 0, so this is what makes "press Enter on
+* `wizard audit`" run the default leaf (today `audit events`).
+*
+* Exported for testability — the ordering logic stays pure and
+* inspectable without mounting Ink.
+*/
+function orderFamilyChildren(children) {
+	const selectable = children.filter((c) => c.handler || c.children?.length);
+	const defaults = selectable.filter((c) => c.default);
+	const rest = selectable.filter((c) => !c.default);
+	return [...defaults, ...rest];
+}
+/**
+* Render the picker. Resolves once the user has selected a child;
+* dispatching the child's handler is the caller's responsibility (so this
+* function stays pure-UI and easy to test by stubbing `render`).
+*/
+function chooseFamilyChild(parentLabel, children) {
+	const ordered = orderFamilyChildren(children);
+	if (ordered.length === 0) return Promise.resolve(null);
+	const options = ordered.map((child) => ({
+		label: describe(child),
+		value: child,
+		hint: child.description
+	}));
+	return new Promise((resolve) => {
+		let app = null;
+		const handleSelect = (cmd) => {
+			app?.unmount();
+			resolve(cmd);
+		};
+		app = render(createElement(FamilyPickerApp, {
+			parentLabel,
+			options,
+			onSelect: handleSelect
+		}));
+	});
+}
+/**
+* Returns an `interactiveDefault` handler for a family parent's no-leaf
+* invocation. Always opens the picker; the `default`-marked child is
+* shown first (pre-highlighted), so a single Enter keystroke runs it.
+*
+* Discovery + consent in one extra keystroke vs. auto-running silently.
+*
+* Wire onto a family parent:
+*   export const auditCommand: Command = {
+*     name: 'audit',
+*     description: '...',
+*     children: [...],
+*     interactiveDefault: createFamilyPickerDefault('audit', auditChildren),
+*   };
+*/
+function createFamilyPickerDefault(parentLabel, children, chooser = chooseFamilyChild) {
+	return async (argv) => {
+		const chosen = await chooser(parentLabel, children);
+		if (!chosen) return;
+		await Promise.resolve(chosen.handler?.(argv));
+	};
+}
+//#endregion
+//#region src/commands/factories/family-command-factory.ts
+/**
+* Build a yargs `Command` for a family parent (`wizard audit`, etc.).
+*
+*   - `wizard <family> <sub>` — `dispatchFamily` resolves `<sub>` against
+*     native handlers first, then the live `cliEntries` from
+*     `skill-menu.json`. Unknown subs error with the available list.
+*   - `wizard <family>` (no positional) — in an interactive terminal, runs the
+*     family's single shown entry directly (today `audit events`, so the user
+*     lands on its intro screen); opens the picker once a family shows more than
+*     one. In non-TTY/CI, falls through to `dispatchFamily`, which prints
+*     "requires a subcommand" rather than running something unprompted.
+*
+* No static yargs children. New skill-backed subcommands appear after a
+* context-mill release without a wizard release. New *native* subcommands
+* (rare) are added by updating `NATIVE_HANDLERS` in `dispatch-family.ts`.
+*/
+function familyCommandFactory({ family, description, optionsFrom }) {
+	const openFamilyEntry = async (argv) => {
+		const toShow = pickerChildrenToShow(buildFamilyPickerChildren(family, (await fetchSkillMenu(getSkillsBaseUrl()))?.cliEntries ?? []));
+		if (toShow.length === 1 && toShow[0]?.handler) {
+			await Promise.resolve(toShow[0].handler(argv));
+			return;
+		}
+		await createFamilyPickerDefault(`wizard ${family}`, toShow)(argv);
+	};
+	return {
+		name: `${family} [skill]`,
+		description,
+		options: mergeCommandOptions(optionsFrom),
+		positionals: { skill: {
+			type: "string",
+			describe: "Subcommand to run (omit to run the default)"
+		} },
+		handler: (argv) => {
+			const sub = argv.skill?.trim();
+			runCommandHandler(() => sub || !process.stdout.isTTY ? dispatchFamily(family, argv) : openFamilyEntry(argv));
+		},
+		interactiveDefault: openFamilyEntry
+	};
+}
+//#endregion
+//#region src/commands/audit.ts
+/**
+* The `wizard audit` family.
+*
+* Subcommands are resolved at runtime: the wizard fetches `cliEntries` from
+* `skill-menu.json` and dispatches based on `parentCommand: 'audit'`. The
+* wizard-native handler for `web-analytics` lives in `NATIVE_HANDLERS` over
+* in `dispatch-family.ts`. `wizard audit` with no positional opens the
+* family picker, which combines native + live entries.
+*
+* Adding a new skill-backed audit subcommand is a context-mill release —
+* no wizard release needed.
+*/
+const auditCommand = familyCommandFactory({
+	family: "audit",
+	description: auditConfig.description,
+	optionsFrom: auditConfig
+});
+//#endregion
+//#region src/commands/doctor.ts
+const doctorCommand = {
+	name: "doctor",
+	description: posthogDoctorConfig.description,
+	options: {
+		...skillProgramOptions,
+		...posthogDoctorConfig.cliOptions ?? {}
+	},
+	handler: (argv) => {
+		const extras = posthogDoctorConfig.mapCliOptions?.(argv) ?? {};
+		const options = {
+			...argv,
+			...extras
+		};
+		if (options.ci) runDoctorCI(options);
+		else runWizard(posthogDoctorConfig, options);
+	}
+};
+const SEVERITY_ORDER = {
+	critical: 0,
+	warning: 1,
+	info: 2
+};
+async function runDoctorCI(options) {
+	setUI(new LoggingUI());
+	const apiKey = options.apiKey ?? readApiKeyFromEnv() ?? void 0;
+	if (!apiKey) {
+		getUI().intro("PostHog Wizard");
+		getUI().log.error("CI mode requires --api-key (personal API key phx_xxx)");
+		emitWizardError({
+			code: ErrorCodes.ArgsMissingApiKey,
+			message: "CI mode requires --api-key (personal API key phx_xxx)"
+		});
+		process.exit(1);
+	}
+	getUI().intro("Welcome to the PostHog setup wizard");
+	getUI().log.info("Running posthog-doctor in CI mode");
+	try {
+		const { getOrAskForProjectData } = await import("./setup-utils-CVS86NYR.js");
+		const { host, accessToken, projectId } = await getOrAskForProjectData({
+			signup: false,
+			ci: true,
+			apiKey,
+			projectId: options.projectId ? Number(options.projectId) : void 0,
+			baseUrl: options.baseUrl
+		});
+		const issues = await fetchHealthIssues(accessToken, host.apiHost, projectId);
+		if (issues.length === 0) {
+			getUI().log.success("No active issues — your project looks healthy.");
+			process.exit(0);
+		}
+		const sorted = [...issues].sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
+		getUI().log.warn(`${issues.length} active issue${issues.length === 1 ? "" : "s"} found:`);
+		for (const issue of sorted) getUI().log.info(`  • [${issue.severity}] ${getKindMeta(issue.kind).title}`);
+		process.exit(1);
+	} catch (error) {
+		const { ApiError } = await import("./api-Cm9UtKZh.js");
+		const message = error instanceof ApiError && error.statusCode === 401 ? "Your PostHog API key is invalid or expired." : error instanceof Error ? error.message : String(error);
+		getUI().log.error(`Doctor failed: ${message}`);
+		emitWizardError({
+			code: error instanceof ApiError && error.statusCode === 401 ? ErrorCodes.AuthInvalidOrExpired : ErrorCodes.InternalUnhandled,
+			message
+		});
+		process.exit(1);
+	}
+}
+//#endregion
+//#region src/commands/migrate.ts
+/**
+* `wizard migrate` — flat skill command, Statsig today.
+*
+* Stays flat while there's only one vendor. When a second vendor lands,
+* restructure into a family with `familyCommandFactory` and publish each
+* vendor as a `cliEntries` entry with `parentCommand: 'migrate'` from
+* context-mill. That move is a deliberate breaking change for users
+* (`wizard migrate` stops running Statsig directly), so do it explicitly
+* when the second vendor arrives, not pre-emptively.
+*/
+const migrateCommand = nativeCommandFactory(migrationConfig);
+//#endregion
+//#region src/commands/revenue.ts
+/**
+* `wizard revenue-analytics` — flat skill command, Stripe today.
+*
+* Stays flat while there's only one provider. Restructure into a family
+* if/when a second provider lands.
+*/
+const revenueCommand = nativeCommandFactory(revenueAnalyticsConfig);
+//#endregion
+//#region src/commands/warehouse.ts
+/**
+* `wizard warehouse` — detect and connect a data warehouse source.
+*
+* Mirrors `revenue-analytics`: flat skill command driven by the
+* warehouse-source program.
+*/
+const warehouseCommand = nativeCommandFactory(warehouseSourceConfig);
+//#endregion
+//#region src/commands/self-driving.ts
+const selfDrivingCommand = {
+	name: "self-driving",
+	description: selfDrivingConfig.description,
+	options: {
+		...skillProgramOptions,
+		integrate: {
+			describe: "Integrate the PostHog SDK first, then set up Self-driving — skips the integration prompt and logs you in via OAuth (no \"create an account?\" question). Use when the project isn't set up yet but you already have a PostHog account.",
+			type: "boolean",
+			default: false
+		},
+		...selfDrivingConfig.cliOptions ?? {}
+	},
+	check: (argv) => {
+		if (argv.signup) throw new Error("`self-driving` cannot run with --signup. Just run `wizard self-driving`: when your project has no PostHog, it asks whether you already have an account and offers to create one for you (no flag needed).");
+		if (argv.ci) throw new Error("`self-driving` cannot run in CI mode — it requires interactive steps (GitHub connect, issue-tracker selection, custom-scout approval).");
+		return true;
+	},
+	handler: (argv) => {
+		const extras = selfDrivingConfig.mapCliOptions?.(argv) ?? {};
+		const options = {
+			...argv,
+			...extras
+		};
+		if (options.ci) runWizardCI(selfDrivingConfig, options);
+		else runWizard(selfDrivingConfig, options);
+	}
+};
+//#endregion
+//#region src/commands/slack.ts
+const slackCommand = {
+	name: "slack",
+	description: "Connect PostHog to your Slack",
+	handler: runSlackConnect,
+	children: [{
+		name: "add",
+		description: "Connect PostHog to your Slack",
+		handler: runSlackConnect
+	}]
+};
+function runSlackConnect(argv) {
+	(async () => {
+		const debug = argv.debug;
+		try {
+			const { startTUI } = await import("./start-tui-Bo2L0bar.js");
+			const { buildSession } = await import("./wizard-session-DGaUHOF3.js");
+			const tui = startTUI(VERSION, Program.SlackConnect);
+			tui.store.session = buildSession({
+				debug,
+				baseUrl: argv.baseUrl
+			});
+		} catch (err) {
+			setUI(new LoggingUI());
+			getUI().log.error(`Connecting Slack requires an interactive terminal. ${err instanceof Error ? err.message : String(err)}`);
+			emitWizardError({
+				code: ErrorCodes.CliInteractiveRequired,
+				message: "Connecting Slack requires an interactive terminal."
+			});
+			process.exit(1);
+		}
+	})();
+}
+//#endregion
+//#region src/commands/upload-sourcemaps.ts
+const uploadSourcemapsCommand = {
+	name: [errorTrackingUploadSourceMapsConfig.command, "upload-sourcemaps"],
+	description: errorTrackingUploadSourceMapsConfig.description,
+	options: {
+		...skillProgramOptions,
+		...errorTrackingUploadSourceMapsConfig.cliOptions ?? {}
+	},
+	handler: (argv) => {
+		const extras = errorTrackingUploadSourceMapsConfig.mapCliOptions?.(argv) ?? {};
+		const options = {
+			...argv,
+			...extras
+		};
+		if (options.ci) runWizardCI(errorTrackingUploadSourceMapsConfig, options);
+		else runWizard(errorTrackingUploadSourceMapsConfig, options);
+	}
+};
+//#endregion
+//#region src/commands/error-tracking.ts
+/**
+* `wizard error-tracking` — flat skill command, set up error tracking today.
+*
+* Wires up exception capture and — where the platform needs it — source-map /
+* debug-symbol upload. Runs the `error-tracking` orchestrator flow, which
+* reuses the integration-v2 install/init mini-agents when the repo has no
+* PostHog integration yet, so it works on uninstrumented projects too.
+*/
+const errorTrackingCommand = nativeCommandFactory(errorTrackingConfig);
+//#endregion
+//#region src/commands/basic-integration/skill.ts
+/** Run an arbitrary context-mill skill by id (`wizard skill <id>`, headless with `--ci`). */
+function runSkillMode(argv) {
+	const skillId = argv.skill;
+	const config = createSkillProgram({
+		skillId,
+		command: "skill",
+		id: "agent-skill",
+		description: `Run skill: ${skillId}`,
+		integrationLabel: skillId,
+		successMessage: `${skillId} completed!`,
+		reportFile: `posthog-${skillId}-report.md`,
+		docsUrl: POSTHOG_DOCS_URL,
+		spinnerMessage: `Running ${skillId}...`,
+		estimatedDurationMinutes: 5
+	});
+	const options = {
+		...argv,
+		skillId
+	};
+	if (argv.ci) runWizardCI(config, options);
+	else runWizard(config, options);
+}
+//#endregion
+//#region src/commands/skill.ts
+/** Read the `<skill-name>` positional (yargs camelCases the hyphenated key). */
+function readSkillName(argv) {
+	return String(argv.skillName ?? argv["skill-name"] ?? "").trim();
+}
+const BROWSABLE_ROLES = new Set(["command", "skill"]);
+/**
+* Reject an unknown skill id before the wizard authenticates.
+*
+* Without this, `readSkillName` accepts any non-empty string and the name is
+* only validated far downstream, when the agent tries to download it — after
+* the user has already logged in. A typo then costs a full auth round-trip
+* (the concern raised in review). We resolve against the same set
+* `downloadSkill` uses (`categories` flattened by `id`), so this never
+* false-rejects a skill the download would have accepted.
+*
+* If the registry is unreachable we stay silent and defer to the download
+* step's own `menu-fetch-failed` handling, rather than adding a second network
+* dependency that could block an otherwise-valid run.
+*/
+async function assertSkillExists(skillName) {
+	const skillsBaseUrl = getSkillsBaseUrl();
+	const menu = await fetchSkillMenu(skillsBaseUrl);
+	if (!menu) return;
+	if (Object.values(menu.categories).flat().some((s) => s.id === skillName)) return;
+	analytics.wizardCapture("cli dispatch error", {
+		reason: "unknown skill",
+		family: "skill",
+		sub: skillName,
+		skillsBaseUrl
+	});
+	try {
+		await analytics.flush();
+	} catch {}
+	throw new Error(`Unknown skill "${skillName}". Run \`wizard skill list\` to see available skills.`);
+}
+function formatEntry(entry) {
+	const path = entry.parentCommand ? `wizard ${entry.parentCommand} ${entry.command}` : entry.command ? `wizard ${entry.command}` : `wizard skill ${entry.skillId}`;
+	return `  ${entry.skillId.padEnd(38)}  ${path.padEnd(36)}  ${entry.description}`;
+}
+/**
+* `wizard skill <skill-name>` — run a single context-mill skill by id.
+* `wizard skill list`         — list every browsable skill in the catalog.
+*
+* Replaces the old `--skill=<id>` flag on the default command. The skill id
+* is fetched from context-mill's release at runtime (same mechanism the flag
+* used), so any published skill id works. Pass `--ci` to run headlessly.
+*/
+const skillCommand = {
+	name: "skill <skill-name>",
+	description: "Run a specific context-mill skill by name (or `list` them)",
+	children: [{
+		name: "list",
+		description: "List every browsable skill in the catalog",
+		handler: () => {
+			runCommandHandler(async () => {
+				const skillsBaseUrl = getSkillsBaseUrl();
+				const menu = await fetchSkillMenu(skillsBaseUrl);
+				if (!menu) {
+					analytics.wizardCapture("cli dispatch error", {
+						reason: "registry unreachable",
+						family: "skill",
+						sub: "list",
+						skillsBaseUrl
+					});
+					try {
+						await analytics.flush();
+					} catch {}
+					process.stderr.write("\n\x1B[1;91m✖ Couldn't reach the skill registry.\x1B[0m\n  Check your network connection and try again.\n\n");
+					emitWizardError({
+						code: ErrorCodes.SkillMenuFetchFailed,
+						message: "Couldn't reach the skill registry."
+					});
+					process.exit(1);
+				}
+				const entries = (menu.cliEntries ?? []).filter((e) => BROWSABLE_ROLES.has(e.role));
+				if (entries.length === 0) {
+					process.stdout.write("No skills found.\n");
+					return;
+				}
+				process.stdout.write(`${entries.length} skill${entries.length === 1 ? "" : "s"}:\n`);
+				process.stdout.write(`  ${"SKILL ID".padEnd(38)}  ${"COMMAND".padEnd(36)}  DESCRIPTION\n`);
+				for (const entry of entries) process.stdout.write(`${formatEntry(entry)}\n`);
+			});
+		}
+	}],
+	options: { ...skillProgramOptions },
+	positionals: { "skill-name": {
+		type: "string",
+		describe: "Skill id to run (e.g. audit-events), or `list`"
+	} },
+	check: (argv) => {
+		if (argv.skillName == null && argv["skill-name"] == null) return true;
+		if (!readSkillName(argv)) throw new Error("skill needs a skill name, e.g. `wizard skill audit-events`");
+		return true;
+	},
+	handler: (argv) => {
+		runCommandHandler(async () => {
+			const skillName = readSkillName(argv);
+			await assertSkillExists(skillName);
+			runSkillMode({
+				...argv,
+				skill: skillName
+			});
+		});
+	}
+};
+//#endregion
+//#region src/commands/cli/add.ts
+const cliAddCommand = {
+	name: "add",
+	description: "Install or update PostHog CLI and add steering instructions to your coding agent's global instructions file",
+	options: {
+		agent: {
+			describe: "Agent to install the instructions for",
+			choices: CLI_STEERING_TARGETS.map((target) => target.id),
+			type: "string"
+		},
+		path: {
+			describe: "Write to an explicit instructions file instead of a detected agent",
+			type: "string"
+		},
+		all: {
+			default: false,
+			describe: "Install for every detected agent without prompting",
+			type: "boolean"
+		}
+	},
+	examples: [
+		["wizard cli add", "Detect your coding agents and pick one"],
+		["wizard cli add --agent claude-code", "Install for Claude Code (~/.claude/CLAUDE.md)"],
+		["wizard cli add --all", "Install for every detected agent"],
+		["wizard cli add --path ./AGENTS.md", "Install into a specific instructions file"]
+	],
+	check: (argv) => {
+		if (argv.all && (argv.agent || argv.path)) throw new Error("--all cannot be combined with --agent or --path");
+		return true;
+	},
+	handler: (argv) => {
+		runCliAdd(argv);
+	}
+};
+async function runCliAdd(argv) {
+	setUI(new LoggingUI());
+	const ui = getUI();
+	ui.intro("PostHog CLI setup");
+	const files = await resolveTargetFiles(argv);
+	if (files.length === 0) {
+		process.exit(1);
+		return;
+	}
+	ui.log.info("Installing or updating PostHog CLI...");
+	const cliInstallResult = installOrUpdatePostHogCli();
+	if (!cliInstallResult.success) {
+		ui.log.error(`Failed to install or update PostHog CLI: ${cliInstallResult.error ?? ""}`);
+		analytics.wizardCapture("cli steering installed", {
+			files: files.length,
+			failures: files.length,
+			cli_install_failed: true,
+			agent: typeof argv.agent === "string" ? argv.agent : void 0
+		});
+		process.exit(1);
+		return;
+	}
+	ui.log.success("Installed or updated PostHog CLI.");
+	let failures = 0;
+	for (const file of files) {
+		const result = installSteeringSnippet(file);
+		if (result.success) ui.log.success(`Installed PostHog steering instructions in ${file}`);
+		else {
+			failures += 1;
+			ui.log.error(`Failed to update ${file}: ${result.error ?? ""}`);
+		}
+	}
+	analytics.wizardCapture("cli steering installed", {
+		files: files.length,
+		failures,
+		agent: typeof argv.agent === "string" ? argv.agent : void 0
+	});
+	if (failures > 0) {
+		process.exit(1);
+		return;
+	}
+	ui.outro("Done. PostHog CLI is installed and your agent will now use `posthog-cli api` for PostHog tasks.");
+	process.exit(0);
+}
+/** Resolve which instruction files to write, from flags, detection, or a prompt. */
+async function resolveTargetFiles(argv) {
+	const ui = getUI();
+	if (typeof argv.path === "string" && argv.path.trim()) return [path$1.resolve(argv.path.trim())];
+	if (typeof argv.agent === "string") {
+		const target = findTarget(argv.agent);
+		if (!target) {
+			ui.log.error(`Unsupported agent: ${argv.agent}`);
+			return [];
+		}
+		return [target.instructionsPath()];
+	}
+	const detected = detectTargets();
+	if (detected.length === 0) {
+		ui.log.error("No supported coding agents detected. Pass --agent <id> or --path <file> to choose a target.");
+		ui.log.info(`Supported agents: ${CLI_STEERING_TARGETS.map((t) => t.id).join(", ")}`);
+		return [];
+	}
+	if (argv.all === true) {
+		ui.log.info(`Installing for all detected agents: ${detected.map((t) => t.name).join(", ")}`);
+		return detected.map((target) => target.instructionsPath());
+	}
+	if (detected.length === 1) {
+		ui.log.info(`Detected ${detected[0].name} (${detected[0].instructionsPath()})`);
+		return [detected[0].instructionsPath()];
+	}
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		ui.log.info(`Installing for all detected agents: ${detected.map((t) => t.name).join(", ")}`);
+		return detected.map((target) => target.instructionsPath());
+	}
+	return (await promptForTargets(detected)).map((target) => target.instructionsPath());
+}
+/** Minimal numbered selection — this command is intentionally not a TUI flow. */
+async function promptForTargets(detected) {
+	const ui = getUI();
+	ui.log.info("Which coding agent are you using?");
+	detected.forEach((target, index) => {
+		ui.log.info(`  ${index + 1}) ${target.name} (${target.instructionsPath()})`);
+	});
+	ui.log.info(`  ${detected.length + 1}) All of the above`);
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		for (;;) {
+			const answer = (await rl.question(`Select 1-${detected.length + 1}: `)).trim();
+			const choice = Number(answer);
+			if (Number.isInteger(choice) && choice >= 1 && choice <= detected.length) return [detected[choice - 1]];
+			if (choice === detected.length + 1) return detected;
+			ui.log.warn(`Enter a number between 1 and ${detected.length + 1}.`);
+		}
+	} finally {
+		rl.close();
+	}
+}
+//#endregion
+//#region src/commands/cli/index.ts
+const cliCommand = {
+	name: "cli",
+	description: "PostHog CLI agent integration commands",
+	children: [cliAddCommand]
+};
+//#endregion
+//#region main.ts
+setGlobalDispatcher(new Agent({ allowH2: false }));
+recoverOrphanedSettingsBackups(resolveInstallDir());
+function resolveInstallDir() {
+	const args = process.argv.slice(2);
+	const flagIndex = args.indexOf("--install-dir");
+	if (flagIndex !== -1 && args[flagIndex + 1]) return args[flagIndex + 1];
+	const inline = args.find((a) => a.startsWith("--install-dir="));
+	if (inline) return inline.slice(14);
+	return process.env.POSTHOG_WIZARD_INSTALL_DIR ?? process.cwd();
+}
+Wizard.use(basicIntegrationCommand).use(mcpCommand).use(mcpAnalyticsCommand).use(replayVisionCommand).use(aiObservabilityCommand).use(metricsCommand).use(cliCommand).use(auditCommand).use(doctorCommand).use(migrateCommand).use(revenueCommand).use(warehouseCommand).use(selfDrivingCommand).use(slackCommand).use(uploadSourcemapsCommand).use(errorTrackingCommand).use(skillCommand).init();
+//#endregion
+export {};
+
+//# sourceMappingURL=main-CgKxbwMP.js.map