@amplitude/wizard 1.0.0-beta.0

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

@@ -0,0 +1,343 @@
+"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.getFlaskVersionBucket = exports.FlaskProjectType = void 0;
+exports.getFlaskVersion = getFlaskVersion;
+exports.getFlaskProjectType = getFlaskProjectType;
+exports.getFlaskProjectTypeName = getFlaskProjectTypeName;
+exports.findFlaskAppFile = findFlaskAppFile;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const ui_1 = require("../../ui");
+const semver_1 = require("../../utils/semver");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+var FlaskProjectType;
+(function (FlaskProjectType) {
+    FlaskProjectType["STANDARD"] = "standard";
+    FlaskProjectType["RESTFUL"] = "restful";
+    FlaskProjectType["RESTX"] = "restx";
+    FlaskProjectType["SMOREST"] = "smorest";
+    FlaskProjectType["BLUEPRINT"] = "blueprint";
+})(FlaskProjectType || (exports.FlaskProjectType = FlaskProjectType = {}));
+const IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/venv/**',
+    '**/.venv/**',
+    '**/env/**',
+    '**/.env/**',
+    '**/__pycache__/**',
+    '**/migrations/**',
+    '**/instance/**',
+];
+/**
+ * Get Flask version bucket for analytics
+ */
+exports.getFlaskVersionBucket = (0, semver_1.createVersionBucket)();
+/**
+ * Extract Flask version from requirements files or pyproject.toml
+ */
+async function getFlaskVersion(options) {
+    const { installDir } = options;
+    // Check requirements files
+    const requirementsFiles = await (0, fast_glob_1.default)(['**/requirements*.txt', '**/pyproject.toml', '**/setup.py', '**/Pipfile'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const reqFile of requirementsFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, reqFile), 'utf-8');
+            // Try to extract version from requirements.txt format (Flask==3.0.0 or flask>=2.0)
+            const requirementsMatch = content.match(/[Ff]lask[=<>~!]+([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+            if (requirementsMatch) {
+                return requirementsMatch[1];
+            }
+            // Try to extract from pyproject.toml format
+            const pyprojectMatch = content.match(/[Ff]lask["\s]*[=<>~!]+\s*["']?([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+            if (pyprojectMatch) {
+                return pyprojectMatch[1];
+            }
+        }
+        catch {
+            // Skip files that can't be read
+            continue;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if Flask-RESTful is installed
+ */
+async function hasFlaskRESTful({ installDir, }) {
+    const requirementsFiles = await (0, fast_glob_1.default)(['**/requirements*.txt', '**/pyproject.toml', '**/Pipfile'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const reqFile of requirementsFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, reqFile), 'utf-8');
+            if (content.includes('flask-restful') ||
+                content.includes('Flask-RESTful')) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Also check imports in Python files
+    const pyFiles = await (0, fast_glob_1.default)(['**/*.py'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const pyFile of pyFiles) {
+        try {
+            const content = fs.readFileSync(path.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 (0, fast_glob_1.default)(['**/requirements*.txt', '**/pyproject.toml', '**/Pipfile'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const reqFile of requirementsFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, reqFile), 'utf-8');
+            if (content.includes('flask-restx') || content.includes('Flask-RESTX')) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Also check imports in Python files
+    const pyFiles = await (0, fast_glob_1.default)(['**/*.py'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const pyFile of pyFiles) {
+        try {
+            const content = fs.readFileSync(path.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 (0, fast_glob_1.default)(['**/requirements*.txt', '**/pyproject.toml', '**/Pipfile'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const reqFile of requirementsFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, reqFile), 'utf-8');
+            if (content.includes('flask-smorest')) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Also check imports in Python files
+    const pyFiles = await (0, fast_glob_1.default)(['**/*.py'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const pyFile of pyFiles) {
+        try {
+            const content = fs.readFileSync(path.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 (0, fast_glob_1.default)(['**/*.py'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const pyFile of pyFiles) {
+        try {
+            const content = fs.readFileSync(path.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;
+    // Check for Flask-RESTX first (most specific - includes Swagger)
+    if (await hasFlaskRESTX({ installDir })) {
+        (0, ui_1.getUI)().setDetectedFramework('Flask-RESTX');
+        return FlaskProjectType.RESTX;
+    }
+    // Check for flask-smorest (OpenAPI-first)
+    if (await hasFlaskSmorest({ installDir })) {
+        (0, ui_1.getUI)().setDetectedFramework('flask-smorest');
+        return FlaskProjectType.SMOREST;
+    }
+    // Check for Flask-RESTful
+    if (await hasFlaskRESTful({ installDir })) {
+        (0, ui_1.getUI)().setDetectedFramework('Flask-RESTful');
+        return FlaskProjectType.RESTFUL;
+    }
+    // Check for Blueprints (large app structure)
+    if (await hasBlueprints({ installDir })) {
+        (0, ui_1.getUI)().setDetectedFramework('Flask with Blueprints');
+        return FlaskProjectType.BLUEPRINT;
+    }
+    // Default to standard Flask
+    (0, ui_1.getUI)().setDetectedFramework('Flask');
+    return FlaskProjectType.STANDARD;
+}
+/**
+ * Get human-readable name for Flask project type
+ */
+function getFlaskProjectTypeName(projectType) {
+    switch (projectType) {
+        case FlaskProjectType.STANDARD:
+            return 'Standard Flask';
+        case FlaskProjectType.RESTFUL:
+            return 'Flask-RESTful';
+        case FlaskProjectType.RESTX:
+            return 'Flask-RESTX';
+        case FlaskProjectType.SMOREST:
+            return 'flask-smorest';
+        case FlaskProjectType.BLUEPRINT:
+            return 'Flask with Blueprints';
+    }
+}
+/**
+ * Find the main Flask app file
+ */
+async function findFlaskAppFile(options) {
+    const { installDir } = options;
+    // Common Flask app file patterns
+    const commonPatterns = [
+        '**/app.py',
+        '**/wsgi.py',
+        '**/application.py',
+        '**/run.py',
+        '**/main.py',
+        '**/__init__.py',
+    ];
+    const appFiles = await (0, fast_glob_1.default)(commonPatterns, {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    // Look for files with Flask() instantiation or create_app() factory
+    for (const appFile of appFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, appFile), 'utf-8');
+            // Check for Flask app instantiation or application factory
+            if (content.includes('Flask(__name__)') ||
+                content.includes('Flask(') ||
+                content.includes('def create_app(')) {
+                return appFile;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // If no file with Flask() found, check all Python files
+    const allPyFiles = await (0, fast_glob_1.default)(['**/*.py'], {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const pyFile of allPyFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, pyFile), 'utf-8');
+            if (content.includes('Flask(__name__)') ||
+                content.includes('def create_app(')) {
+                return pyFile;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Return first common pattern file if exists
+    if (appFiles.length > 0) {
+        return appFiles[0];
+    }
+    return undefined;
+}

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

@@ -0,0 +1,4 @@
+import type { FrameworkConfig } from '../../lib/framework-config';
+type FlutterContext = Record<string, unknown>;
+export declare const FLUTTER_AGENT_CONFIG: FrameworkConfig<FlutterContext>;
+export {};

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLUTTER_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.FLUTTER_AGENT_CONFIG = {
+    metadata: {
+        name: 'Flutter',
+        integration: constants_1.Integration.flutter,
+        beta: true,
+        docsUrl: 'https://amplitude.com/docs/sdks/analytics/flutter/flutter-sdk-4',
+    },
+    detection: {
+        packageName: 'amplitude_flutter',
+        packageDisplayName: 'Flutter',
+        usesPackageJson: false,
+        getVersion: () => undefined,
+        detect: utils_1.detectFlutterProject,
+        detectPackageManager: package_manager_detection_1.flutterPackageManager,
+    },
+    environment: {
+        // Flutter apps don't use .env files — API keys are passed via --dart-define
+        // or stored in a constants file; the agent handles key storage
+        uploadToHosting: false,
+        getEnvVars: () => ({}),
+    },
+    analytics: {
+        getTags: () => ({}),
+    },
+    prompts: {
+        projectTypeDetection: 'This is a Flutter project. Look for pubspec.yaml with a flutter SDK reference, and android/ + ios/ directories.',
+        packageInstallation: 'Use Flutter pub: run `flutter pub add amplitude_flutter` to add the dependency (pubspec.yaml and pubspec.lock are updated automatically).',
+        getAdditionalContextLines: () => [
+            'Framework docs ID: flutter (use amplitude://docs/frameworks/flutter for documentation)',
+            'SDK: amplitude_flutter (pub.dev)',
+            'Initialization: final amplitude = Amplitude(Configuration(apiKey: const String.fromEnvironment("AMPLITUDE_API_KEY"))); await amplitude.isBuilt;',
+            'Always await amplitude.isBuilt before calling track() or flush()',
+            'Store the API key via --dart-define at build time (flutter run --dart-define=AMPLITUDE_API_KEY=...), not hardcoded in source',
+        ],
+    },
+    ui: {
+        successMessage: 'Amplitude integration complete',
+        estimatedDurationMinutes: 8,
+        getOutroChanges: () => [
+            'Analyzed your Flutter project structure',
+            'Added amplitude_flutter to pubspec.yaml via flutter pub add',
+            'Configured Amplitude initialization with default session tracking',
+        ],
+        getOutroNextSteps: () => [
+            'Run your app on a device or simulator to verify the integration',
+            'Visit your Amplitude dashboard to see incoming events',
+            'Use amplitude.track(BaseEvent("Event Name")) for custom events',
+            'Pass the API key at build time: flutter run --dart-define=AMPLITUDE_API_KEY=your_key',
+        ],
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { WizardOptions } from '../../utils/types';
+/**
+ * Returns true when the directory contains a Flutter project.
+ * A Flutter project has pubspec.yaml that references the flutter SDK,
+ * or has the characteristic android/ + ios/ sibling directories.
+ */
+export declare function detectFlutterProject(options: Pick<WizardOptions, 'installDir'>): Promise<boolean>;

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

@@ -0,0 +1,64 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFlutterProject = detectFlutterProject;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/**
+ * Returns true when the directory contains a Flutter project.
+ * A Flutter project has pubspec.yaml that references the flutter SDK,
+ * or has the characteristic android/ + ios/ sibling directories.
+ */
+function detectFlutterProject(options) {
+    const { installDir } = options;
+    const pubspecPath = path.join(installDir, 'pubspec.yaml');
+    if (!fs.existsSync(pubspecPath)) {
+        return Promise.resolve(false);
+    }
+    // Check for flutter SDK reference in pubspec.yaml
+    try {
+        const content = fs.readFileSync(pubspecPath, 'utf-8');
+        if (/^\s*flutter\s*:/m.test(content) || content.includes('sdk: flutter')) {
+            return Promise.resolve(true);
+        }
+    }
+    catch {
+        // fall through to directory check
+    }
+    // Fallback: typical Flutter project has both android/ and ios/ dirs
+    const hasAndroid = fs.existsSync(path.join(installDir, 'android'));
+    const hasIos = fs.existsSync(path.join(installDir, 'ios'));
+    return Promise.resolve(hasAndroid && hasIos);
+}

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

@@ -0,0 +1,2 @@
+import type { FrameworkConfig } from '../../lib/framework-config';
+export declare const GENERIC_AGENT_CONFIG: FrameworkConfig;

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

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERIC_AGENT_CONFIG = void 0;
+const constants_1 = require("../../lib/constants");
+const package_manager_detection_1 = require("../../lib/package-manager-detection");
+exports.GENERIC_AGENT_CONFIG = {
+    metadata: {
+        name: 'Generic',
+        integration: constants_1.Integration.generic,
+        docsUrl: 'https://amplitude.com/docs/get-started/amplitude-quickstart',
+    },
+    detection: {
+        packageName: '',
+        packageDisplayName: 'Generic',
+        usesPackageJson: false,
+        getVersion: () => undefined,
+        detectPackageManager: package_manager_detection_1.detectNodePackageManagers,
+        detect: () => Promise.resolve(false),
+    },
+    environment: {
+        uploadToHosting: false,
+        getEnvVars: (apiKey, host) => ({
+            AMPLITUDE_API_KEY: apiKey,
+            AMPLITUDE_SERVER_URL: host,
+        }),
+    },
+    analytics: {
+        getTags: () => ({}),
+    },
+    prompts: {
+        projectTypeDetection: 'n/a',
+        buildPrompt: ({ projectApiKey, host, typescript }) => {
+            // Derive browser-side HTTP API endpoint from the server-side ingestion host.
+            // The Browser SDK uses a different endpoint from the server-side SDK.
+            const browserApiUrl = host.includes('eu.')
+                ? 'https://api.eu.amplitude.com/2/httpapi'
+                : 'https://api2.amplitude.com/2/httpapi';
+            return `
+You are integrating Amplitude analytics into a project.
+
+Project context:
+- Amplitude public API key: ${projectApiKey}
+- Amplitude server-side host (Node.js / Python / server SDKs): ${host}
+- Amplitude browser API URL (Browser SDK / CDN snippet): ${browserApiUrl}
+- TypeScript: ${typescript ? 'Yes' : 'No'}
+
+Use [STATUS] <message> at the start of any line to report progress (e.g. "[STATUS] Reading project structure"). These are shown to the user in the terminal.
+
+Instructions (follow IN ORDER):
+
+STEP 1: Check if Amplitude is already integrated.
+Search the project for existing Amplitude references (e.g. "amplitude" in source files or templates).
+- If Amplitude code is already present: skip to STEP 6 (build verification) and diagnose any issues.
+- If not: continue to STEP 2.
+
+STEP 2: Understand the project.
+[STATUS] Analysing project structure
+Use Glob to list key manifest files (package.json, requirements.txt, Gemfile, go.mod, netlify.toml, config.toml, etc.) and read the main entry point to determine the language and framework.
+
+STEP 3: Choose the SDK and fetch documentation.
+[STATUS] Fetching Amplitude documentation
+Choose the correct SDK based on the project type, then fetch its docs:
+
+SDK selection (choose the FIRST match):
+- Browser / SPA / SSG (JS running in a browser):
+    Recommended: @amplitude/unified
+      npm install @amplitude/unified
+      import { initAll } from '@amplitude/unified';
+      initAll(API_KEY, { analytics: { autocapture: true } });
+    Alternative: @amplitude/analytics-browser
+      npm install @amplitude/analytics-browser
+      amplitude.init(API_KEY, { autocapture: { pageViews: true, sessions: true, formInteractions: true, fileDownloads: true } });
+    Static site (no build pipeline): CDN snippet — see https://amplitude.com/docs/sdks/analytics/browser/browser-sdk-2
+- Node.js server:
+    npm install @amplitude/analytics-node
+    import { init, track, flush } from '@amplitude/analytics-node';
+    init(API_KEY); ... await flush().promise;
+- Python:
+    pip install amplitude-analytics
+    from amplitude import Amplitude, BaseEvent
+    client = Amplitude(API_KEY)
+    client.track(BaseEvent(event_type="Event", user_id="user"))
+- EU data residency: pass serverZone: 'EU' (JS) or client.configuration.server_zone = 'EU' (Python)
+- Angular: initialize OUTSIDE Angular's zone: ngZone.runOutsideAngular(() => amplitude.init(API_KEY, options))
+- SvelteKit/Astro: env var prefix is PUBLIC_ (e.g. PUBLIC_AMPLITUDE_API_KEY)
+
+Env var naming by framework:
+- Next.js: NEXT_PUBLIC_AMPLITUDE_API_KEY (browser), AMPLITUDE_API_KEY (server)
+- Vite / Vue: VITE_AMPLITUDE_API_KEY
+- SvelteKit / Astro: PUBLIC_AMPLITUDE_API_KEY
+- Create React App: REACT_APP_AMPLITUDE_API_KEY
+- Node.js / Python / generic server: AMPLITUDE_API_KEY
+
+Use WebFetch to load the specific SDK docs if needed for exact API details.
+
+STEP 4: Install and initialise the Amplitude SDK.
+[STATUS] Installing Amplitude SDK
+If the project uses a package manager: use the detect_package_manager tool to find it, then install the appropriate SDK package as a background task and proceed immediately.
+If the project is a static site with no server-side build pipeline (e.g. Zola, Hugo, Jekyll, Eleventy): use the CDN script tag approach instead, and store the API key in the site's config file (e.g. config.toml, config.yaml, _config.yml) — that is the correct pattern for static sites, not a .env file.
+For all other projects: reference env vars for the API key — never hardcode them in source files.
+
+Add a sample tracking call demonstrating the integration.
+
+BROWSER SDK / CDN SNIPPET — SERVER URL AND CORS:
+When using the Amplitude Browser SDK (whether via CDN <script> tag or npm package in a browser context), you MUST:
+1. Set serverUrl to the browser API URL: ${browserApiUrl}
+   This is NOT the same as the server-side host. Using the wrong URL will cause CORS errors or silent failures.
+   Example initialisation:
+     amplitude.init('${projectApiKey}', { serverUrl: '${browserApiUrl}' });
+2. If the project is deployed on Netlify (netlify.toml present), add a reverse proxy redirect AND
+   CORS headers so events go through the site's own domain (bypasses ad blockers):
+   In netlify.toml:
+     [[redirects]]
+       from = "/amplitude-api/*"
+       to = "${host.includes('eu.')
+                ? 'https://api.eu.amplitude.com'
+                : 'https://api2.amplitude.com'}/:splat"
+       status = 200
+       force = true
+     [[headers]]
+       for = "/amplitude-api/*"
+       [headers.values]
+         Access-Control-Allow-Origin = "*"
+         Access-Control-Allow-Methods = "GET, POST, OPTIONS"
+         Access-Control-Allow-Headers = "Content-Type"
+   Then set serverUrl to '/amplitude-api/2/httpapi' in the SDK init (or site config file).
+3. If the project has a local dev server with a proxy config (Vite, webpack-dev-server, Next.js, etc.),
+   add a proxy rule so that requests to /amplitude-api are forwarded to ${browserApiUrl}.
+   Then set serverUrl to '/amplitude-api/2/httpapi' in the SDK init.
+   Only do this if the framework has a built-in proxy mechanism.
+4. If there is no proxy mechanism (plain static site, no dev server, no Netlify), use the direct browserApiUrl.
+   CORS is supported by Amplitude's API, so it will work in production. In local development,
+   ad blockers or browser extensions may block requests — this is expected and not a code issue.
+
+STEP 4b: Update Content Security Policy (CSP).
+[STATUS] Checking Content Security Policy
+This is MANDATORY — do not skip it even if the SDK was already present.
+Search the entire project for any CSP definitions using Grep:
+- Grep for "Content-Security-Policy" across all files
+- Also check: netlify.toml, _headers, vercel.json, next.config.*, nginx.conf, .htaccess, any HTML <meta http-equiv="Content-Security-Policy"> tags
+If any CSP is found, read the file and add the following to the relevant directives:
+- script-src: https://*.amplitude.com
+- connect-src: https://*.amplitude.com
+Update ALL locations where a CSP is defined (there may be more than one).
+If no CSP is found, skip to STEP 5.
+
+STEP 5: Set environment variables (skip for static sites that store config in a site config file).
+[STATUS] Writing environment variables
+For projects that use env vars: use the wizard-tools MCP server.
+- Use check_env_keys to see what already exists.
+- Use set_env_values to write the API key and server URL.
+  The tool ensures .gitignore coverage automatically.
+  Use the naming convention for the framework (e.g. NEXT_PUBLIC_AMPLITUDE_API_KEY for Next.js, VITE_AMPLITUDE_API_KEY for Vite, AMPLITUDE_API_KEY for Node.js/Python/etc.).
+  For browser SDK projects, store AMPLITUDE_SERVER_URL=${browserApiUrl}.
+  For server-side SDK projects, store AMPLITUDE_SERVER_URL=${host}.
+
+STEP 6: Verify the build.
+[STATUS] Verifying build
+Run the project's build command and check it exits cleanly:
+- Package manager projects: use the detected package manager (e.g. npm run build, pnpm build, cargo build, go build, ./gradlew build)
+- Static site generators: run the site's build command (e.g. zola build, hugo, jekyll build, mkdocs build, eleventy)
+If the build fails, read the error output, fix the issue, and run it again. Repeat until the build passes or you have exhausted reasonable fixes.
+
+Important: You must read a file immediately before writing it. Always use environment variables — never hardcode the public token.
+`.trim();
+        },
+    },
+    ui: {
+        successMessage: 'Amplitude integration complete',
+        estimatedDurationMinutes: 5,
+        getOutroChanges: () => ['Amplitude SDK installed and initialized'],
+        getOutroNextSteps: () => [
+            'Verify events are appearing in your Amplitude project dashboard',
+        ],
+    },
+};

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

@@ -0,0 +1,4 @@
+import type { FrameworkConfig } from '../../lib/framework-config';
+type GoContext = Record<string, unknown>;
+export declare const GO_AGENT_CONFIG: FrameworkConfig<GoContext>;
+export {};