@amplitude/wizard 1.0.0-beta.0

package/dist/src/frameworks/nextjs/nextjs-wizard-agent.d.ts

@@ -0,0 +1,7 @@
+import type { FrameworkConfig } from '../../lib/framework-config';
+import { NextJsRouter } from './utils';
+type NextjsContext = {
+    router?: NextJsRouter;
+};
+export declare const NEXTJS_AGENT_CONFIG: FrameworkConfig<NextjsContext>;
+export {};

package/dist/src/frameworks/nextjs/nextjs-wizard-agent.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEXTJS_AGENT_CONFIG = void 0;
+const package_manager_detection_1 = require("../../lib/package-manager-detection");
+const constants_1 = require("../../lib/constants");
+const package_json_1 = require("../../utils/package-json");
+const setup_utils_1 = require("../../utils/setup-utils");
+const ui_1 = require("../../ui");
+const utils_1 = require("./utils");
+exports.NEXTJS_AGENT_CONFIG = {
+    metadata: {
+        name: 'Next.js',
+        integration: constants_1.Integration.nextjs,
+        docsUrl: 'https://amplitude.com/docs/sdks/analytics/browser/browser-sdk-2',
+        unsupportedVersionDocsUrl: 'https://amplitude.com/docs/sdks/analytics/browser/browser-sdk-2',
+        gatherContext: async (options) => {
+            const router = await (0, utils_1.getNextJsRouter)(options);
+            if (router) {
+                const emoji = router === utils_1.NextJsRouter.APP_ROUTER ? '\u{1F4F1}' : '\u{1F4C3}';
+                (0, ui_1.getUI)().setDetectedFramework(`Next.js ${(0, utils_1.getNextJsRouterName)(router)} ${emoji}`);
+                return { router };
+            }
+            return {};
+        },
+        setup: {
+            questions: [
+                {
+                    key: 'router',
+                    message: 'Which Next.js router are you using?',
+                    options: [
+                        { label: 'App Router', value: utils_1.NextJsRouter.APP_ROUTER },
+                        { label: 'Pages Router', value: utils_1.NextJsRouter.PAGES_ROUTER },
+                    ],
+                    detect: async (opts) => {
+                        const result = await (0, utils_1.getNextJsRouter)(opts);
+                        return result;
+                    },
+                },
+            ],
+        },
+    },
+    detection: {
+        packageName: 'next',
+        packageDisplayName: 'Next.js',
+        getVersion: (packageJson) => (0, package_json_1.getPackageVersion)('next', packageJson),
+        getVersionBucket: utils_1.getNextJsVersionBucket,
+        minimumVersion: '15.3.0',
+        getInstalledVersion: async (options) => {
+            const packageJson = await (0, setup_utils_1.tryGetPackageJson)(options);
+            return packageJson ? (0, package_json_1.getPackageVersion)('next', packageJson) : undefined;
+        },
+        detect: async (options) => {
+            const packageJson = await (0, setup_utils_1.tryGetPackageJson)(options);
+            return packageJson ? (0, package_json_1.hasPackageInstalled)('next', packageJson) : false;
+        },
+        detectPackageManager: package_manager_detection_1.detectNodePackageManagers,
+    },
+    environment: {
+        uploadToHosting: true,
+        getEnvVars: (apiKey, _host) => ({
+            NEXT_PUBLIC_AMPLITUDE_API_KEY: apiKey,
+        }),
+    },
+    analytics: {
+        getTags: (context) => ({
+            router: context.router === utils_1.NextJsRouter.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) => {
+            const routerType = context.router === utils_1.NextJsRouter.APP_ROUTER ? 'app' : 'pages';
+            return [
+                `Router: ${routerType}`,
+                `Preferred Amplitude SDK: @amplitude/unified (prefer over @amplitude/analytics-browser for new browser integrations)`,
+            ];
+        },
+    },
+    ui: {
+        successMessage: 'Amplitude integration complete',
+        estimatedDurationMinutes: 8,
+        getOutroChanges: (context) => {
+            const router = context.router ?? utils_1.NextJsRouter.APP_ROUTER;
+            const routerName = (0, utils_1.getNextJsRouterName)(router);
+            return [
+                `Analyzed your Next.js project structure (${routerName})`,
+                `Created and configured Amplitude initializers`,
+                `Integrated Amplitude into your application`,
+            ];
+        },
+        getOutroNextSteps: () => {
+            return [
+                'Start your development server to see Amplitude in action',
+                'Visit your Amplitude dashboard to see incoming events',
+            ];
+        },
+    },
+};

package/dist/src/frameworks/nextjs/utils.d.ts

@@ -0,0 +1,12 @@
+import type { WizardOptions } from '../../utils/types';
+export declare const getNextJsVersionBucket: (version: string | undefined) => string;
+export declare enum NextJsRouter {
+    APP_ROUTER = "app-router",
+    PAGES_ROUTER = "pages-router"
+}
+export declare const IGNORE_PATTERNS: string[];
+/**
+ * Detect Next.js router type. Pure — returns null if ambiguous.
+ */
+export declare function getNextJsRouter({ installDir, }: Pick<WizardOptions, 'installDir'>): Promise<NextJsRouter | null>;
+export declare const getNextJsRouterName: (router: NextJsRouter) => "app router" | "pages router";

package/dist/src/frameworks/nextjs/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextJsRouterName = exports.IGNORE_PATTERNS = exports.NextJsRouter = exports.getNextJsVersionBucket = void 0;
+exports.getNextJsRouter = getNextJsRouter;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const semver_1 = require("../../utils/semver");
+exports.getNextJsVersionBucket = (0, semver_1.createVersionBucket)();
+var NextJsRouter;
+(function (NextJsRouter) {
+    NextJsRouter["APP_ROUTER"] = "app-router";
+    NextJsRouter["PAGES_ROUTER"] = "pages-router";
+})(NextJsRouter || (exports.NextJsRouter = NextJsRouter = {}));
+exports.IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/public/**',
+    '**/.next/**',
+];
+/**
+ * Detect Next.js router type. Pure — returns null if ambiguous.
+ */
+async function getNextJsRouter({ installDir, }) {
+    const pagesMatches = await (0, fast_glob_1.default)('**/pages/_app.@(ts|tsx|js|jsx)', {
+        dot: true,
+        cwd: installDir,
+        ignore: exports.IGNORE_PATTERNS,
+    });
+    const hasPagesDir = pagesMatches.length > 0;
+    const appMatches = await (0, fast_glob_1.default)('**/app/**/layout.@(ts|tsx|js|jsx)', {
+        dot: true,
+        cwd: installDir,
+        ignore: exports.IGNORE_PATTERNS,
+    });
+    const hasAppDir = appMatches.length > 0;
+    if (hasPagesDir && !hasAppDir) {
+        return NextJsRouter.PAGES_ROUTER;
+    }
+    if (hasAppDir && !hasPagesDir) {
+        return NextJsRouter.APP_ROUTER;
+    }
+    // Ambiguous (both or neither) — return null, SetupScreen handles it
+    return null;
+}
+const getNextJsRouterName = (router) => {
+    return router === NextJsRouter.APP_ROUTER ? 'app router' : 'pages router';
+};
+exports.getNextJsRouterName = getNextJsRouterName;

package/dist/src/frameworks/python/python-wizard-agent.d.ts

@@ -0,0 +1,7 @@
+import type { FrameworkConfig } from '../../lib/framework-config';
+import { PythonPackageManager } from './utils';
+type PythonContext = {
+    packageManager?: PythonPackageManager;
+};
+export declare const PYTHON_AGENT_CONFIG: FrameworkConfig<PythonContext>;
+export {};

package/dist/src/frameworks/python/python-wizard-agent.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PYTHON_AGENT_CONFIG = void 0;
+const framework_config_1 = require("../../lib/framework-config");
+const package_manager_detection_1 = require("../../lib/package-manager-detection");
+const constants_1 = require("../../lib/constants");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const utils_1 = require("./utils");
+exports.PYTHON_AGENT_CONFIG = {
+    metadata: {
+        name: 'Python Language',
+        integration: constants_1.Integration.python,
+        beta: true,
+        docsUrl: 'https://amplitude.com/docs/sdks/analytics/python',
+        gatherContext: async (options) => {
+            const packageManager = await (0, utils_1.detectPackageManager)(options);
+            return { packageManager };
+        },
+    },
+    detection: {
+        packageName: 'python',
+        packageDisplayName: 'Python',
+        usesPackageJson: false,
+        getVersion: () => undefined,
+        getVersionBucket: utils_1.getPythonVersionBucket,
+        minimumVersion: '3.8.0',
+        getInstalledVersion: (options) => Promise.resolve((0, utils_1.getPythonVersion)(options)),
+        detect: async (options) => {
+            const { installDir } = options;
+            // Look for Python package management files
+            const pythonConfigFiles = await (0, fast_glob_1.default)([
+                '**/requirements*.txt',
+                '**/pyproject.toml',
+                '**/setup.py',
+                '**/Pipfile',
+            ], {
+                cwd: installDir,
+                ignore: ['**/venv/**', '**/.venv/**', '**/env/**', '**/.env/**'],
+            });
+            if (pythonConfigFiles.length === 0) {
+                return false;
+            }
+            // Make sure this isn't Django or Flask (those should be detected first)
+            // Check for Django
+            const managePyMatches = await (0, fast_glob_1.default)('**/manage.py', {
+                cwd: installDir,
+                ignore: ['**/venv/**', '**/.venv/**', '**/env/**', '**/.env/**'],
+            });
+            for (const match of managePyMatches) {
+                try {
+                    const content = fs.readFileSync(path.join(installDir, match), 'utf-8');
+                    if (content.includes('django') ||
+                        content.includes('DJANGO_SETTINGS_MODULE')) {
+                        return false; // Django detected, use django agent instead
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Check for Flask
+            for (const configFile of pythonConfigFiles) {
+                try {
+                    const content = fs.readFileSync(path.join(installDir, configFile), 'utf-8');
+                    if (/^flask([<>=~!]|$|\s)/im.test(content) ||
+                        /["']flask["']/i.test(content)) {
+                        return false; // Flask detected, use flask agent instead
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            const pyFiles = await (0, fast_glob_1.default)(['**/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.readFileSync(path.join(installDir, pyFile), 'utf-8');
+                    if (content.includes('from flask import') ||
+                        content.includes('import flask') ||
+                        /Flask\s*\(/.test(content)) {
+                        return false; // Flask detected, use flask agent instead
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // If we have Python config files but it's not Django or Flask, it's a generic Python project
+            return true;
+        },
+        detectPackageManager: package_manager_detection_1.detectPythonPackageManagers,
+    },
+    environment: {
+        uploadToHosting: false,
+        getEnvVars: (apiKey, _host) => ({
+            AMPLITUDE_API_KEY: apiKey,
+        }),
+    },
+    analytics: {
+        getTags: (context) => {
+            const packageManagerName = context.packageManager
+                ? (0, utils_1.getPackageManagerName)(context.packageManager)
+                : 'unknown';
+            return {
+                packageManager: packageManagerName,
+            };
+        },
+    },
+    prompts: {
+        packageInstallation: framework_config_1.PYTHON_PACKAGE_INSTALLATION,
+        projectTypeDetection: 'This is a generic Python project. Look for requirements.txt, pyproject.toml, setup.py, or Pipfile to confirm.',
+        getAdditionalContextLines: (context) => {
+            const packageManagerName = context.packageManager
+                ? (0, utils_1.getPackageManagerName)(context.packageManager)
+                : 'unknown';
+            return [
+                `Package manager: ${packageManagerName}`,
+                `Framework docs ID: python (use amplitude://docs/frameworks/python for documentation)`,
+                `Project type: Generic Python application (CLI, script, worker, data pipeline, etc.)`,
+            ];
+        },
+    },
+    ui: {
+        successMessage: 'Amplitude integration complete',
+        estimatedDurationMinutes: 5,
+        getOutroChanges: (context) => {
+            const packageManagerName = context.packageManager
+                ? (0, utils_1.getPackageManagerName)(context.packageManager)
+                : 'package manager';
+            return [
+                `Analyzed your Python project structure`,
+                `Installed the Amplitude Python package using ${packageManagerName}`,
+                `Created Amplitude initialization using instance-based API (Amplitude class)`,
+                `Configured exception autocapture and graceful shutdown`,
+                `Added example code for events, feature flags, and error capture (without PII)`,
+            ];
+        },
+        getOutroNextSteps: () => [
+            'Use the Amplitude client for all tracking calls',
+            'Call amplitude_client.shutdown() on application exit (use atexit.register)',
+            'NEVER send PII in event properties (no emails, names, or user content)',
+            'Use amplitude_client.track() for events and amplitude_client.identify() for users',
+            'Visit your Amplitude dashboard to see incoming events',
+        ],
+    },
+};

package/dist/src/frameworks/python/utils.d.ts

@@ -0,0 +1,28 @@
+import type { WizardOptions } from '../../utils/types';
+export declare enum PythonPackageManager {
+    UV = "uv",
+    POETRY = "poetry",
+    PDM = "pdm",
+    HATCH = "hatch",
+    RYE = "rye",
+    PIPENV = "pipenv",
+    CONDA = "conda",
+    PIP = "pip",
+    UNKNOWN = "unknown"
+}
+/**
+ * Get the installed Python version
+ */
+export declare function getPythonVersion(options: WizardOptions): string | undefined;
+/**
+ * Bucket Python version for analytics (e.g., "3.11.x" -> "3.11")
+ */
+export declare function getPythonVersionBucket(version: string): string;
+/**
+ * Detect which package manager the project uses
+ */
+export declare function detectPackageManager(options: WizardOptions): Promise<PythonPackageManager>;
+/**
+ * Get package manager display name
+ */
+export declare function getPackageManagerName(packageManager: PythonPackageManager): string;

package/dist/src/frameworks/python/utils.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonPackageManager = void 0;
+exports.getPythonVersion = getPythonVersion;
+exports.getPythonVersionBucket = getPythonVersionBucket;
+exports.detectPackageManager = detectPackageManager;
+exports.getPackageManagerName = getPackageManagerName;
+const node_child_process_1 = require("node:child_process");
+var PythonPackageManager;
+(function (PythonPackageManager) {
+    PythonPackageManager["UV"] = "uv";
+    PythonPackageManager["POETRY"] = "poetry";
+    PythonPackageManager["PDM"] = "pdm";
+    PythonPackageManager["HATCH"] = "hatch";
+    PythonPackageManager["RYE"] = "rye";
+    PythonPackageManager["PIPENV"] = "pipenv";
+    PythonPackageManager["CONDA"] = "conda";
+    PythonPackageManager["PIP"] = "pip";
+    PythonPackageManager["UNKNOWN"] = "unknown";
+})(PythonPackageManager || (exports.PythonPackageManager = PythonPackageManager = {}));
+/**
+ * Get the installed Python version
+ */
+function getPythonVersion(options) {
+    try {
+        const version = (0, node_child_process_1.execSync)('python --version || python3 --version', {
+            cwd: options.installDir,
+            encoding: 'utf-8',
+        })
+            .trim()
+            .replace('Python ', '');
+        return version;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Bucket Python version for analytics (e.g., "3.11.x" -> "3.11")
+ */
+function getPythonVersionBucket(version) {
+    const match = version.match(/^(\d+\.\d+)/);
+    return match ? match[1] : version;
+}
+/**
+ * Detect which package manager the project uses
+ */
+async function detectPackageManager(options) {
+    const { installDir } = options;
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    // Check for uv (uv.lock)
+    if (fs.existsSync(path.join(installDir, 'uv.lock'))) {
+        return PythonPackageManager.UV;
+    }
+    // Check pyproject.toml for various tools
+    if (fs.existsSync(path.join(installDir, 'pyproject.toml'))) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, 'pyproject.toml'), 'utf-8');
+            // Check for Poetry
+            if (content.includes('[tool.poetry]')) {
+                return PythonPackageManager.POETRY;
+            }
+            // Check for PDM
+            if (content.includes('[tool.pdm]')) {
+                return PythonPackageManager.PDM;
+            }
+            // Check for Hatch
+            if (content.includes('[tool.hatch]')) {
+                return PythonPackageManager.HATCH;
+            }
+            // Check for Rye
+            if (content.includes('[tool.rye]')) {
+                return PythonPackageManager.RYE;
+            }
+        }
+        catch {
+            // Continue checking
+        }
+    }
+    // Check for Poetry lock file
+    if (fs.existsSync(path.join(installDir, 'poetry.lock'))) {
+        return PythonPackageManager.POETRY;
+    }
+    // Check for PDM lock file
+    if (fs.existsSync(path.join(installDir, 'pdm.lock'))) {
+        return PythonPackageManager.PDM;
+    }
+    // Check for Pipenv (Pipfile or Pipfile.lock)
+    if (fs.existsSync(path.join(installDir, 'Pipfile')) ||
+        fs.existsSync(path.join(installDir, 'Pipfile.lock'))) {
+        return PythonPackageManager.PIPENV;
+    }
+    // Check for Conda (environment.yml or environment.yaml)
+    if (fs.existsSync(path.join(installDir, 'environment.yml')) ||
+        fs.existsSync(path.join(installDir, 'environment.yaml'))) {
+        return PythonPackageManager.CONDA;
+    }
+    // Check for pip (requirements.txt, setup.py, setup.cfg, or pyproject.toml)
+    if (fs.existsSync(path.join(installDir, 'requirements.txt')) ||
+        fs.existsSync(path.join(installDir, 'setup.py')) ||
+        fs.existsSync(path.join(installDir, 'setup.cfg')) ||
+        fs.existsSync(path.join(installDir, 'pyproject.toml'))) {
+        return PythonPackageManager.PIP;
+    }
+    // Check for requirements directory
+    try {
+        const requirementsDir = path.join(installDir, 'requirements');
+        if (fs.existsSync(requirementsDir) &&
+            fs.statSync(requirementsDir).isDirectory()) {
+            const files = fs.readdirSync(requirementsDir);
+            if (files.some((f) => f.endsWith('.txt'))) {
+                return PythonPackageManager.PIP;
+            }
+        }
+    }
+    catch {
+        // Continue
+    }
+    return PythonPackageManager.UNKNOWN;
+}
+/**
+ * Get package manager display name
+ */
+function getPackageManagerName(packageManager) {
+    switch (packageManager) {
+        case PythonPackageManager.UV:
+            return 'uv';
+        case PythonPackageManager.POETRY:
+            return 'Poetry';
+        case PythonPackageManager.PDM:
+            return 'PDM';
+        case PythonPackageManager.HATCH:
+            return 'Hatch';
+        case PythonPackageManager.RYE:
+            return 'Rye';
+        case PythonPackageManager.PIPENV:
+            return 'Pipenv';
+        case PythonPackageManager.CONDA:
+            return 'Conda';
+        case PythonPackageManager.PIP:
+            return 'pip';
+        case PythonPackageManager.UNKNOWN:
+            return 'unknown';
+    }
+}

package/dist/src/frameworks/react-native/react-native-wizard-agent.d.ts

@@ -0,0 +1,6 @@
+import type { FrameworkConfig } from '../../lib/framework-config';
+type ReactNativeContext = {
+    isExpo?: boolean;
+};
+export declare const REACT_NATIVE_AGENT_CONFIG: FrameworkConfig<ReactNativeContext>;
+export {};

package/dist/src/frameworks/react-native/react-native-wizard-agent.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REACT_NATIVE_AGENT_CONFIG = void 0;
+const package_manager_detection_1 = require("../../lib/package-manager-detection");
+const constants_1 = require("../../lib/constants");
+const utils_1 = require("./utils");
+exports.REACT_NATIVE_AGENT_CONFIG = {
+    metadata: {
+        name: 'React Native',
+        integration: constants_1.Integration.reactNative,
+        beta: true,
+        docsUrl: 'https://amplitude.com/docs/sdks/analytics/react-native/react-native-sdk',
+        gatherContext: async (options) => {
+            const isExpo = await (0, utils_1.detectExpo)(options);
+            return { isExpo };
+        },
+    },
+    detection: {
+        packageName: 'react-native',
+        packageDisplayName: 'React Native',
+        usesPackageJson: true,
+        getVersion: () => undefined,
+        detect: utils_1.detectReactNativeProject,
+        detectPackageManager: package_manager_detection_1.detectNodePackageManagers,
+    },
+    environment: {
+        uploadToHosting: false,
+        // Expo uses EXPO_PUBLIC_ prefix; bare RN uses plain env vars via react-native-config.
+        // The agent handles the correct naming based on context — we write a neutral key
+        // here as a placeholder and the agent will rename as appropriate.
+        getEnvVars: (apiKey, host) => ({
+            AMPLITUDE_API_KEY: apiKey,
+            AMPLITUDE_SERVER_URL: host,
+        }),
+    },
+    analytics: {
+        getTags: (context) => ({
+            isExpo: context.isExpo ? 'true' : 'false',
+        }),
+    },
+    prompts: {
+        projectTypeDetection: 'This is a JavaScript/TypeScript project. Look for package.json with a `react-native` dependency to confirm.',
+        packageInstallation: 'Use the detect_package_manager tool. For Expo projects use `expo install`; for bare React Native use npm/yarn/pnpm. Always install both @amplitude/analytics-react-native AND @react-native-async-storage/async-storage. For bare React Native, also run `cd ios && pod install` after installing.',
+        getAdditionalContextLines: (context) => {
+            const envVarName = context.isExpo
+                ? 'EXPO_PUBLIC_AMPLITUDE_API_KEY'
+                : 'AMPLITUDE_API_KEY';
+            const installCmd = context.isExpo
+                ? 'expo install @amplitude/analytics-react-native @react-native-async-storage/async-storage'
+                : 'npm install @amplitude/analytics-react-native @react-native-async-storage/async-storage';
+            return [
+                `Project type: ${context.isExpo ? 'Expo' : 'Bare React Native'}`,
+                `Framework docs ID: react-native (use amplitude://docs/frameworks/react-native for documentation)`,
+                `SDK: @amplitude/analytics-react-native — do NOT use @amplitude/unified (not supported for React Native)`,
+                `Install command: ${installCmd}`,
+                `Environment variable name: ${envVarName}`,
+                `Initialization: import { init } from '@amplitude/analytics-react-native'; init(process.env.${envVarName});`,
+                context.isExpo
+                    ? `Expo env vars require the EXPO_PUBLIC_ prefix to be available in client-side code`
+                    : `For bare RN, use react-native-config or inline the key via a constants file — never commit API keys to source`,
+            ];
+        },
+    },
+    ui: {
+        successMessage: 'Amplitude integration complete',
+        estimatedDurationMinutes: 8,
+        getOutroChanges: (context) => {
+            const variant = context.isExpo ? 'Expo' : 'Bare React Native';
+            return [
+                `Analyzed your ${variant} project structure`,
+                `Installed @amplitude/analytics-react-native and async-storage peer dependency`,
+                `Configured Amplitude initialization`,
+            ];
+        },
+        getOutroNextSteps: (context) => [
+            context.isExpo
+                ? 'Run `expo start` to launch the app and verify events'
+                : 'Run `npx react-native run-ios` or `run-android` to verify events',
+            'Visit your Amplitude dashboard to see incoming events',
+            "Use track('Event Name', { prop: value }) for custom events",
+            'Use setUserId("user@example.com") to associate events with users',
+        ],
+    },
+};

package/dist/src/frameworks/react-native/utils.d.ts

@@ -0,0 +1,21 @@
+import type { WizardOptions } from '../../utils/types';
+/**
+ * Returns true when the directory contains a React Native project.
+ *
+ * Primary signal: package.json with `react-native` in dependencies or
+ * devDependencies. This is the definitive indicator that distinguishes
+ * React Native from:
+ *   - Plain web apps (Next.js, Vite, CRA) — no `react-native` dep
+ *   - Pure Android native projects — no package.json at all
+ *   - Flutter — uses pubspec.yaml, detected earlier in the pipeline
+ *
+ * Note: The `javascript-web` detector already excludes `react-native`
+ * via FRAMEWORK_PACKAGES, and this detector runs before `android` in
+ * the registry so AndroidManifest.xml overlap is not a concern.
+ */
+export declare function detectReactNativeProject(options: Pick<WizardOptions, 'installDir'>): Promise<boolean>;
+/**
+ * Returns true if the React Native project uses Expo.
+ * Checks for `expo` package or an app.json with a top-level "expo" key.
+ */
+export declare function detectExpo(options: Pick<WizardOptions, 'installDir'>): Promise<boolean>;