Migrate from Flagsmith, in both directions.

# Route A - the UI bulk export: Project Settings -> Export tab, pick the
# source environment, download JSON. Covers flags, values and multivariate
# weights. Segments are NOT included, and exports expire after two weeks
# (both per Flagsmith's own docs), so keep a local copy.

# Route B - the environment document: the JSON Flagsmith's local-evaluation
# SDKs consume. One environment's feature states AND segment rules, no
# identities/traits. Their CLI outputs it (authenticate with a server-side
# "ser." environment key; see the flagsmith-cli README):
npx flagsmith-cli environment document > flagsmith-production.json

// migrate.mjs - Flagsmith environment document -> wagle BatchWrite ops.
// Converts the mechanical part (on/off features, single-value config) and
// PRINTS what needs your judgment (multivariate splits, segment rules)
// instead of guessing. It is your script, not a wagle feature - adapt it.
import { readFileSync, writeFileSync } from "node:fs";

const ENV = "production"; // the wagle environment this batch lands in
const doc = JSON.parse(readFileSync(process.argv[2], "utf8"));
const ops = [];
const review = [];

for (const state of doc.feature_states ?? []) {
  const key = state.feature.name;
  const value = state.feature_state_value;
  if ((state.multivariate_feature_state_values ?? []).length > 0) {
    review.push(`${key}: multivariate split -> write a rollout rule by hand`);
    continue;
  }
  const serving = { enabled: state.enabled, defaultVariationKey: "on", offVariationKey: "off" };
  const flag =
    value == null
      ? {
          // pure on/off feature -> a BOOL flag
          key,
          valueType: "VALUE_TYPE_BOOL",
          variations: [
            { key: "on", value: "true" },
            { key: "off", value: "false" },
          ],
          environments: { [ENV]: serving },
        }
      : {
          // remote-config value -> a typed flag; wagle values are ALWAYS strings
          key,
          valueType: typeof value === "number" ? "VALUE_TYPE_NUMBER" : "VALUE_TYPE_STRING",
          variations: [
            { key: "on", value: String(value) },
            { key: "off", value: "" },
          ],
          environments: { [ENV]: serving },
        };
  ops.push({ flag });
}

for (const segment of doc.project?.segments ?? []) {
  review.push(`segment ${segment.name}: translate rules by hand (flat ANDed conditions)`);
}

writeFileSync("ops.json", JSON.stringify(ops, null, 2));
console.log(`${ops.length} ops -> ops.json`);
if (review.length) console.log(`needs review:\n- ${review.join("\n- ")}`);

# One BatchWrite applies every op all-or-nothing under a SINGLE config
# version bump: an invalid op rejects the whole batch and nothing is written,
# and no SDK ever observes a half-imported config. Run it once per target
# environment. Example ops: a segment, then a flag that references it.
curl -sS $WAGLE_URL/api.admin.v1.AdminService/BatchWrite \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $WAGLE_TOKEN" \
  -d '{
    "project": "baseline",
    "environment": "production",
    "ops": [
      {"segment": {"key": "beta-testers", "conditions": [
        {"attribute": "plan", "op": "OPERATOR_IN", "values": ["pro", "enterprise"]}
      ]}},
      {"flag": {
        "key": "new-checkout",
        "valueType": "VALUE_TYPE_BOOL",
        "variations": [{"key": "on", "value": "true"}, {"key": "off", "value": "false"}],
        "environments": {"production": {
          "enabled": true,
          "defaultVariationKey": "off",
          "offVariationKey": "off",
          "rules": [
            {"conditions": [{"op": "OPERATOR_IN_SEGMENT", "values": ["beta-testers"]}],
             "variationKey": "on"},
            {"conditions": [],
             "rollout": {"entries": [
               {"variationKey": "on", "weight": 2500},
               {"variationKey": "off", "weight": 7500}
             ]}}
          ]
        }}
      }}
    ]
  }'
# -> {"models":{...},"graphs":[...],"version":"1"}

# Spot-check evaluations against what Flagsmith served for the same
# identity + traits. Reasons tell you WHY a variation was served.
curl -sS $WAGLE_URL/api.eval.v1.EvaluationService/Evaluate \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $WAGLE_TOKEN" \
  -d '{"project":"baseline","environment":"production","flagKey":"new-checkout",
       "context":{"entityId":"user-42","attributes":{"plan":"pro"}}}'
# -> {"variationKey":"on","value":"true","reason":"REASON_TARGET_MATCH",...}

# The import itself is auditable: it landed as ONE config version, attributed
# to you, diffable per flag.
curl -sS $WAGLE_URL/api.admin.v1.AdminService/GetHistory \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $WAGLE_TOKEN" \
  -d '{"project":"baseline","environment":"production"}'

# The whole config of one (project, environment) is two list calls: flags
# (identity + per-env serving state + rules) and segments. That JSON is
# yours; there is nothing else to ask for and no export gate to unlock.
curl -sS $WAGLE_URL/api.admin.v1.AdminService/ListFlags \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $WAGLE_TOKEN" \
  -d '{"project":"baseline","environment":"production"}'
# -> {"models":{"flags":[...]},"graphs":[...]}

curl -sS $WAGLE_URL/api.admin.v1.AdminService/ListSegments \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $WAGLE_TOKEN" \
  -d '{"project":"baseline","environment":"production"}'
# -> {"models":{"segments":[...]},"graphs":[...]}

# Going back to Flagsmith is this page in reverse: reshape into their bulk
# import format (Project Settings -> Import tab) or replay their Admin API.

{
  "mcpServers": {
    "wagle-admin": {
      "type": "http",
      "url": "$WAGLE_URL/mcp",
      "headers": { "Authorization": "Bearer <refresh-credential>" }
    }
  }
}

# Register the endpoint once (Claude Code shown; any MCP host works):
claude mcp add --transport http wagle-admin \
  $WAGLE_URL/mcp \
  --header "Authorization: Bearer <refresh-credential>"

# Then hand it your export and this page's rules in one ask:

> Here is a Flagsmith environment document (attached:
  flagsmith-production.json). Recreate it in my wagle project "baseline",
  environment "production":
  - segments first: flat ANDed conditions; skip anything with nested
    any/all rule trees and tell me what you skipped and why;
  - each feature becomes a flag: pure on/off -> a BOOL flag; a valued
    feature -> a typed flag whose "on" variation carries the value
    (values are strings);
  - multivariate splits -> a rollout rule, weights in basis points
    summing to exactly 10000;
  - keep every key byte-identical, except rename a feature named "new"
    (reserved key) and flag it to me.
  When done, list everything you created, then evaluate new-checkout
  for user-42 with plan=pro so I can compare against Flagsmith.