@amplitude/wizard 1.0.0-beta.0

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

@@ -0,0 +1,305 @@
+"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.getDjangoVersionBucket = exports.DjangoProjectType = void 0;
+exports.getDjangoVersion = getDjangoVersion;
+exports.getDjangoProjectType = getDjangoProjectType;
+exports.getDjangoProjectTypeName = getDjangoProjectTypeName;
+exports.findDjangoSettingsFile = findDjangoSettingsFile;
+exports.findDjangoUrlsFile = findDjangoUrlsFile;
+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 DjangoProjectType;
+(function (DjangoProjectType) {
+    DjangoProjectType["STANDARD"] = "standard";
+    DjangoProjectType["DRF"] = "drf";
+    DjangoProjectType["WAGTAIL"] = "wagtail";
+    DjangoProjectType["CHANNELS"] = "channels";
+})(DjangoProjectType || (exports.DjangoProjectType = DjangoProjectType = {}));
+const IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/venv/**',
+    '**/.venv/**',
+    '**/env/**',
+    '**/.env/**',
+    '**/__pycache__/**',
+    '**/migrations/**',
+];
+/**
+ * Get Django version bucket for analytics
+ */
+exports.getDjangoVersionBucket = (0, semver_1.createVersionBucket)();
+/**
+ * Extract Django version from requirements files or pyproject.toml
+ */
+async function getDjangoVersion(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 (Django==4.2.0 or Django>=4.0)
+            const requirementsMatch = content.match(/[Dd]jango[=<>~!]+([0-9]+\.[0-9]+(?:\.[0-9]+)?)/);
+            if (requirementsMatch) {
+                return requirementsMatch[1];
+            }
+            // Try to extract from pyproject.toml format
+            const pyprojectMatch = content.match(/[Dd]jango["\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 Django REST Framework is installed
+ */
+async function hasDRF({ 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('djangorestframework')) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Also check INSTALLED_APPS in settings
+    const settingsFiles = await (0, fast_glob_1.default)('**/settings.py', {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    for (const settingsFile of settingsFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, settingsFile), 'utf-8');
+            if (content.includes('rest_framework')) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+/**
+ * Check if Wagtail is installed
+ */
+async function hasWagtail({ 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('wagtail')) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+/**
+ * Check if Django Channels is installed
+ */
+async function hasChannels({ 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('channels')) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+/**
+ * Detect Django project type
+ */
+async function getDjangoProjectType(options) {
+    const { installDir } = options;
+    // Check for Wagtail first (CMS)
+    if (await hasWagtail({ installDir })) {
+        (0, ui_1.getUI)().setDetectedFramework('Django with Wagtail CMS');
+        return DjangoProjectType.WAGTAIL;
+    }
+    // Check for Django REST Framework
+    if (await hasDRF({ installDir })) {
+        (0, ui_1.getUI)().setDetectedFramework('Django REST Framework');
+        return DjangoProjectType.DRF;
+    }
+    // Check for Django Channels
+    if (await hasChannels({ installDir })) {
+        (0, ui_1.getUI)().setDetectedFramework('Django Channels');
+        return DjangoProjectType.CHANNELS;
+    }
+    // Default to standard Django
+    (0, ui_1.getUI)().setDetectedFramework('Django');
+    return DjangoProjectType.STANDARD;
+}
+/**
+ * Get human-readable name for Django project type
+ */
+function getDjangoProjectTypeName(projectType) {
+    switch (projectType) {
+        case DjangoProjectType.STANDARD:
+            return 'Standard Django';
+        case DjangoProjectType.DRF:
+            return 'Django REST Framework';
+        case DjangoProjectType.WAGTAIL:
+            return 'Wagtail CMS';
+        case DjangoProjectType.CHANNELS:
+            return 'Django Channels';
+    }
+}
+/**
+ * Find the main Django settings file
+ */
+async function findDjangoSettingsFile(options) {
+    const { installDir } = options;
+    // Look for settings.py files
+    const settingsFiles = await (0, fast_glob_1.default)('**/settings.py', {
+        cwd: installDir,
+        ignore: IGNORE_PATTERNS,
+    });
+    if (settingsFiles.length === 0) {
+        // Try settings/__init__.py for split settings
+        const splitSettingsFiles = await (0, fast_glob_1.default)('**/settings/__init__.py', {
+            cwd: installDir,
+            ignore: IGNORE_PATTERNS,
+        });
+        if (splitSettingsFiles.length > 0) {
+            return splitSettingsFiles[0];
+        }
+        return undefined;
+    }
+    // If multiple settings files, prefer the one next to manage.py or in root
+    if (settingsFiles.length === 1) {
+        return settingsFiles[0];
+    }
+    // Try to find the main settings file by looking for ROOT_URLCONF
+    for (const settingsFile of settingsFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, settingsFile), 'utf-8');
+            if (content.includes('ROOT_URLCONF')) {
+                return settingsFile;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Default to first found
+    return settingsFiles[0];
+}
+/**
+ * Find the main Django urls.py file
+ */
+async function findDjangoUrlsFile(options) {
+    const { installDir } = options;
+    // First, try to find the root urls.py referenced in settings
+    const settingsFile = await findDjangoSettingsFile(options);
+    if (settingsFile) {
+        try {
+            const settingsContent = fs.readFileSync(path.join(installDir, settingsFile), 'utf-8');
+            const urlconfMatch = settingsContent.match(/ROOT_URLCONF\s*=\s*['"]([^'"]+)['"]/);
+            if (urlconfMatch) {
+                const urlconfPath = urlconfMatch[1].replace(/\./g, '/') + '.py';
+                const fullPath = path.join(installDir, urlconfPath);
+                if (fs.existsSync(fullPath)) {
+                    return urlconfPath;
+                }
+            }
+        }
+        catch {
+            // Fall through to glob search
+        }
+    }
+    // Fallback to glob search
+    const urlsFiles = await (0, fast_glob_1.default)('**/urls.py', {
+        cwd: installDir,
+        ignore: [...IGNORE_PATTERNS, '**/admin/**'],
+    });
+    if (urlsFiles.length === 0) {
+        return undefined;
+    }
+    // Prefer urls.py files that contain urlpatterns
+    for (const urlsFile of urlsFiles) {
+        try {
+            const content = fs.readFileSync(path.join(installDir, urlsFile), 'utf-8');
+            if (content.includes('urlpatterns')) {
+                return urlsFile;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return urlsFiles[0];
+}

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

@@ -0,0 +1,11 @@
+import type { FrameworkConfig } from '../../lib/framework-config';
+import { FastAPIProjectType } from './utils';
+interface FastAPIContext extends Record<string, unknown> {
+    projectType?: FastAPIProjectType;
+    appFile?: string;
+}
+/**
+ * FastAPI framework configuration for the universal agent runner
+ */
+export declare const FASTAPI_AGENT_CONFIG: FrameworkConfig<FastAPIContext>;
+export {};

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

@@ -0,0 +1,189 @@
+"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.FASTAPI_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 utils_1 = require("./utils");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/**
+ * FastAPI framework configuration for the universal agent runner
+ */
+exports.FASTAPI_AGENT_CONFIG = {
+    metadata: {
+        name: 'FastAPI',
+        integration: constants_1.Integration.fastapi,
+        docsUrl: 'https://amplitude.com/docs/sdks/analytics/python',
+        unsupportedVersionDocsUrl: 'https://amplitude.com/docs/sdks/analytics/python',
+        gatherContext: async (options) => {
+            const projectType = await (0, utils_1.getFastAPIProjectType)(options);
+            const appFile = await (0, utils_1.findFastAPIAppFile)(options);
+            return { projectType, appFile };
+        },
+    },
+    detection: {
+        packageName: 'fastapi',
+        packageDisplayName: 'FastAPI',
+        usesPackageJson: false,
+        getVersion: (_packageJson) => {
+            // For FastAPI, we don't use package.json. Version is extracted separately
+            // from requirements.txt or pyproject.toml in the wizard entry point
+            return undefined;
+        },
+        getVersionBucket: utils_1.getFastAPIVersionBucket,
+        getInstalledVersion: utils_1.getFastAPIVersion,
+        detect: async (options) => {
+            const { installDir } = options;
+            // Note: Django and Flask are checked before FastAPI in INTEGRATION_ORDER,
+            // so if we get here, the project is not a Django or Flask project.
+            // Check for FastAPI in requirements files
+            const requirementsFiles = await (0, fast_glob_1.default)([
+                '**/requirements*.txt',
+                '**/pyproject.toml',
+                '**/setup.py',
+                '**/Pipfile',
+            ], {
+                cwd: installDir,
+                ignore: ['**/venv/**', '**/.venv/**', '**/env/**', '**/.env/**'],
+            });
+            for (const reqFile of requirementsFiles) {
+                try {
+                    const content = fs.readFileSync(path.join(installDir, reqFile), 'utf-8');
+                    // Check for fastapi package (case-insensitive)
+                    // Match "fastapi" as a standalone package
+                    if (/^fastapi([<>=~!]|$|\s)/im.test(content) ||
+                        /["']fastapi["']/i.test(content)) {
+                        return true;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Check for FastAPI app patterns in Python files
+            const pyFiles = await (0, fast_glob_1.default)(['**/main.py', '**/app.py', '**/application.py', '**/__init__.py'], {
+                cwd: installDir,
+                ignore: [
+                    '**/venv/**',
+                    '**/.venv/**',
+                    '**/env/**',
+                    '**/.env/**',
+                    '**/__pycache__/**',
+                ],
+            });
+            for (const pyFile of pyFiles) {
+                try {
+                    const content = fs.readFileSync(path.join(installDir, pyFile), 'utf-8');
+                    if (content.includes('from fastapi import') ||
+                        content.includes('import fastapi') ||
+                        /FastAPI\s*\(/.test(content)) {
+                        return true;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            return false;
+        },
+        detectPackageManager: package_manager_detection_1.detectPythonPackageManagers,
+    },
+    environment: {
+        uploadToHosting: false,
+        getEnvVars: (apiKey, _host) => ({
+            AMPLITUDE_API_KEY: apiKey,
+        }),
+    },
+    analytics: {
+        getTags: (context) => {
+            const projectType = context.projectType;
+            return {
+                projectType: projectType || 'unknown',
+            };
+        },
+    },
+    prompts: {
+        packageInstallation: framework_config_1.PYTHON_PACKAGE_INSTALLATION,
+        projectTypeDetection: 'This is a Python/FastAPI project. Look for requirements.txt, pyproject.toml, setup.py, Pipfile, or main.py/app.py to confirm.',
+        getAdditionalContextLines: (context) => {
+            const projectType = context.projectType;
+            const projectTypeName = projectType
+                ? (0, utils_1.getFastAPIProjectTypeName)(projectType)
+                : 'unknown';
+            // Map project type to framework ID for MCP docs resource
+            const frameworkIdMap = {
+                [utils_1.FastAPIProjectType.STANDARD]: 'fastapi',
+                [utils_1.FastAPIProjectType.ROUTER]: 'fastapi',
+                [utils_1.FastAPIProjectType.FULLSTACK]: 'fastapi',
+            };
+            const frameworkId = projectType ? frameworkIdMap[projectType] : 'fastapi';
+            const lines = [
+                `Project type: ${projectTypeName}`,
+                `Framework docs ID: ${frameworkId} (use amplitude://docs/frameworks/${frameworkId} for documentation)`,
+            ];
+            if (context.appFile) {
+                lines.push(`App file: ${String(context.appFile)}`);
+            }
+            return lines;
+        },
+    },
+    ui: {
+        successMessage: 'Amplitude integration complete',
+        estimatedDurationMinutes: 5,
+        getOutroChanges: (context) => {
+            const projectType = context.projectType;
+            const projectTypeName = projectType
+                ? (0, utils_1.getFastAPIProjectTypeName)(projectType)
+                : 'FastAPI';
+            return [
+                `Analyzed your ${projectTypeName} project structure`,
+                `Installed the Amplitude Python package`,
+                `Configured Amplitude in your FastAPI application`,
+                `Added Amplitude initialization with lifespan event handling`,
+            ];
+        },
+        getOutroNextSteps: () => [
+            'Start your FastAPI development server to see Amplitude in action',
+            'Visit your Amplitude dashboard to see incoming events',
+            'Use amplitude.identify() to associate events with users',
+        ],
+    },
+};

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

@@ -0,0 +1,26 @@
+import type { WizardOptions } from '../../utils/types';
+export declare enum FastAPIProjectType {
+    STANDARD = "standard",// Basic FastAPI app
+    ROUTER = "router",// FastAPI with APIRouter
+    FULLSTACK = "fullstack"
+}
+/**
+ * Get FastAPI version bucket for analytics
+ */
+export declare function getFastAPIVersionBucket(version: string | undefined): string;
+/**
+ * Extract FastAPI version from requirements files or pyproject.toml
+ */
+export declare function getFastAPIVersion(options: Pick<WizardOptions, 'installDir'>): Promise<string | undefined>;
+/**
+ * Detect FastAPI project type
+ */
+export declare function getFastAPIProjectType(options: WizardOptions): Promise<FastAPIProjectType>;
+/**
+ * Get human-readable name for FastAPI project type
+ */
+export declare function getFastAPIProjectTypeName(projectType: FastAPIProjectType): string;
+/**
+ * Find the main FastAPI app file
+ */
+export declare function findFastAPIAppFile(options: Pick<WizardOptions, 'installDir'>): Promise<string | undefined>;