optimizely-mcp-server 1.0.0 → 1.0.2

package/dist/index.js

@@ -360,6 +360,230 @@ server.tool("create_flag_variation", "Create a new variation for a feature flag
     });
     return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 });
+// ─── Create Full Test (auto-discovers required_ metrics) ────────────────────
+const WEB_VITALS = new Set(["required_fcp", "required_lcp", "required_ttfb", "required_cls", "required_inp"]);
+const AD_LOADTIME_KEYS = new Set(["leaderboard_ad_loadtime"]);
+function classifyEvent(evt) {
+    const key = evt.key;
+    const metrics = [];
+    if (key === "required_o_ad_slot_views") {
+        metrics.push({
+            event_id: evt.id,
+            aggregator: "count",
+            scope: "visitor",
+            winning_direction: "increasing",
+            display_title: key,
+        });
+        metrics.push({
+            event_id: evt.id,
+            aggregator: "sum",
+            scope: "visitor",
+            winning_direction: "increasing",
+            display_title: "ad impression value",
+            field: "value",
+        });
+    }
+    else if (WEB_VITALS.has(key)) {
+        metrics.push({
+            event_id: evt.id,
+            aggregator: "sum",
+            scope: "event",
+            winning_direction: "decreasing",
+            display_title: key,
+            field: "value",
+        });
+    }
+    else if (AD_LOADTIME_KEYS.has(key)) {
+        metrics.push({
+            event_id: evt.id,
+            aggregator: "sum",
+            scope: "event",
+            winning_direction: "decreasing",
+            display_title: key,
+            field: "value",
+        });
+    }
+    else if (key.startsWith("required_o_") || key === "required_pages_visited") {
+        metrics.push({
+            event_id: evt.id,
+            aggregator: "sum",
+            scope: "visitor",
+            winning_direction: "increasing",
+            display_title: key,
+            field: "value",
+        });
+    }
+    else if (key.startsWith("required_saw_") || key.startsWith("required_finished_")) {
+        metrics.push({
+            event_id: evt.id,
+            aggregator: "unique",
+            scope: "visitor",
+            winning_direction: "increasing",
+            display_title: key,
+        });
+    }
+    else if (key.startsWith("required_")) {
+        metrics.push({
+            event_id: evt.id,
+            aggregator: "unique",
+            scope: "visitor",
+            winning_direction: "increasing",
+            display_title: key,
+        });
+    }
+    return metrics;
+}
+async function fetchAllEvents(projectId) {
+    const allEvents = [];
+    let page = 1;
+    while (true) {
+        const batch = await client.request({
+            path: "/v2/events",
+            params: { project_id: projectId, per_page: 100, page },
+        });
+        if (!Array.isArray(batch) || batch.length === 0)
+            break;
+        allEvents.push(...batch);
+        if (batch.length < 100)
+            break;
+        page++;
+    }
+    return allEvents;
+}
+async function buildStandardMetrics(projectId) {
+    const events = await fetchAllEvents(projectId);
+    const metrics = [];
+    for (const evt of events) {
+        if (evt.key.startsWith("required_") || AD_LOADTIME_KEYS.has(evt.key)) {
+            metrics.push(...classifyEvent(evt));
+        }
+    }
+    return metrics;
+}
+server.tool("create_full_test", "Create a fully configured A/B test with a feature flag, Off/On variations, and all standard required_ metrics auto-discovered from the project. Sets up rules in both development and production environments. This replicates what the internal dashboard does.", {
+    project_id: z.number().describe("The project ID"),
+    flag_key: z.string().describe("Unique flag key (alphanumeric, underscores, hyphens)"),
+    flag_name: z.string().describe("Human-readable name (typically the Jira ticket, e.g. 'FFD-8700: My Feature Test')"),
+    rule_name: z.string().optional().describe("Name for the A/B test rule (defaults to flag_key)"),
+    primary_metric_key: z.string().optional().describe("Key of the primary metric event (defaults to 'required_o_ad_slot_views')"),
+    traffic_allocation: z.number().optional().describe("Traffic allocation percentage (0-10000 basis points, default 100 = 1%)"),
+    extra_metrics: z
+        .array(z.object({
+        event_name: z.string().describe("Event name/key to search for"),
+        aggregator: z.enum(["unique", "count", "sum"]).optional().describe("Aggregator (default unique)"),
+        scope: z.enum(["visitor", "event"]).optional().describe("Scope (default visitor)"),
+        winning_direction: z.enum(["increasing", "decreasing"]).optional().describe("Winning direction (default increasing)"),
+        field: z.string().optional().describe("Field name for sum aggregator (e.g. 'value')"),
+    }))
+        .optional()
+        .describe("Additional test-specific metrics beyond the standard required_ set"),
+}, async ({ project_id, flag_key, flag_name, rule_name, primary_metric_key, traffic_allocation, extra_metrics }) => {
+    const results = [];
+    const ruleName = rule_name ?? flag_key;
+    const primaryKey = primary_metric_key ?? "required_o_ad_slot_views";
+    const traffic = traffic_allocation ?? 100;
+    // 1. Create the feature flag
+    const flag = await client.request({
+        method: "POST",
+        path: `/flags/v1/projects/${project_id}/flags`,
+        body: { key: flag_key, name: flag_name },
+    });
+    results.push(`Created flag: ${flag_key} (${flag_name})`);
+    // 2. Auto-discover standard metrics
+    const standardMetrics = await buildStandardMetrics(project_id);
+    results.push(`Auto-discovered ${standardMetrics.length} standard metrics from required_ events`);
+    // 3. Resolve extra metrics by matching event names
+    const allMetrics = [...standardMetrics];
+    if (extra_metrics && extra_metrics.length > 0) {
+        const events = await fetchAllEvents(project_id);
+        for (const em of extra_metrics) {
+            const match = events.find((e) => e.key === em.event_name || e.name === em.event_name);
+            if (match) {
+                const m = {
+                    event_id: match.id,
+                    aggregator: em.aggregator ?? "unique",
+                    scope: em.scope ?? "visitor",
+                    winning_direction: em.winning_direction ?? "increasing",
+                    display_title: em.event_name,
+                };
+                if (em.field)
+                    m.field = em.field;
+                allMetrics.unshift(m);
+                results.push(`Added extra metric: ${em.event_name}`);
+            }
+            else {
+                results.push(`Warning: event '${em.event_name}' not found, skipped`);
+            }
+        }
+    }
+    // 4. Find the primary metric event ID
+    const events = await fetchAllEvents(project_id);
+    const primaryEvent = events.find((e) => e.key === primaryKey);
+    const primaryMetricDisplay = primaryKey;
+    // 5. Create A/B rule in both environments
+    for (const env of ["development", "production"]) {
+        const envRuleName = env === "production" ? `${ruleName}prod` : ruleName;
+        try {
+            await client.request({
+                method: "POST",
+                path: `/flags/v1/projects/${project_id}/flags/${flag_key}/environments/${env}/rules`,
+                body: {
+                    key: ruleName,
+                    name: envRuleName,
+                    type: "a/b",
+                    traffic_allocation: traffic,
+                    distribution_mode: "manual",
+                    variations: [
+                        { key: "off", name: "Off", weight: 5000 },
+                        { key: "on", name: "On", weight: 5000 },
+                    ],
+                },
+            });
+            results.push(`Created A/B rule in ${env}: ${envRuleName}`);
+        }
+        catch (err) {
+            results.push(`Warning: Could not create rule in ${env}: ${err}`);
+        }
+    }
+    // 6. Attach metrics to the experiment(s)
+    const flagData = await client.request({
+        path: `/flags/v1/projects/${project_id}/flags/${flag_key}`,
+    });
+    const environments = flagData.environments ?? {};
+    for (const [envKey, envData] of Object.entries(environments)) {
+        const rules = envData.rules_detail ?? [];
+        for (const rule of rules) {
+            if (rule.layer_experiment_id) {
+                try {
+                    await client.request({
+                        method: "PATCH",
+                        path: `/v2/experiments/${rule.layer_experiment_id}`,
+                        body: { metrics: allMetrics },
+                    });
+                    results.push(`Attached ${allMetrics.length} metrics to ${envKey} experiment (${rule.layer_experiment_id})`);
+                }
+                catch (err) {
+                    results.push(`Warning: Could not attach metrics in ${envKey}: ${err}`);
+                }
+            }
+        }
+    }
+    const summary = [
+        `\n=== Test Created Successfully ===`,
+        `Flag: ${flag_key}`,
+        `Name: ${flag_name}`,
+        `Variations: Off / On`,
+        `Traffic: ${traffic / 100}%`,
+        `Primary Metric: ${primaryMetricDisplay}`,
+        `Standard Metrics: ${standardMetrics.length} (auto-discovered from required_ events)`,
+        `Extra Metrics: ${extra_metrics?.length ?? 0}`,
+        `Environments: development, production`,
+        ``,
+        `--- Log ---`,
+        ...results,
+    ].join("\n");
+    return { content: [{ type: "text", text: summary }] };
+});
 // ─── Start the server ────────────────────────────────────────────────────────
 async function main() {
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optimizely-mcp-server",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MCP server for the Optimizely REST API — manage experiments, feature flags, audiences, and more from any MCP client.",
   "type": "module",
   "main": "dist/index.js",