@launchdarkly/mcp-server 0.4.0 → 0.4.2

package/bin/mcp-server.js

@@ -34236,9 +34236,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "2.0",
-    sdkVersion: "0.4.0",
+    sdkVersion: "0.4.2",
     genVersion: "2.654.2",
-    userAgent: "speakeasy-sdk/typescript 0.4.0 2.654.2 2.0 @launchdarkly/mcp-server"
+    userAgent: "speakeasy-sdk/typescript 0.4.2 2.654.2 2.0 @launchdarkly/mcp-server"
   };
 });
 
@@ -37197,6 +37197,123 @@ var init_aiconfigvariationsresponse = __esm(() => {
   })(AIConfigVariationsResponse$ ||= {});
 });
 
+// src/models/components/approvalsettings.ts
+var ApprovalSettings$inboundSchema, ApprovalSettings$outboundSchema, ApprovalSettings$;
+var init_approvalsettings = __esm(() => {
+  init_esm();
+  ApprovalSettings$inboundSchema = objectType({
+    required: booleanType(),
+    bypassApprovalsForPendingChanges: booleanType(),
+    minNumApprovals: numberType().int(),
+    canReviewOwnRequest: booleanType(),
+    canApplyDeclinedChanges: booleanType(),
+    autoApplyApprovedChanges: booleanType().optional(),
+    serviceKind: stringType(),
+    serviceConfig: recordType(anyType()),
+    requiredApprovalTags: arrayType(stringType()),
+    serviceKindConfigurationId: stringType().optional(),
+    resourceKind: stringType().optional()
+  });
+  ApprovalSettings$outboundSchema = objectType({
+    required: booleanType(),
+    bypassApprovalsForPendingChanges: booleanType(),
+    minNumApprovals: numberType().int(),
+    canReviewOwnRequest: booleanType(),
+    canApplyDeclinedChanges: booleanType(),
+    autoApplyApprovedChanges: booleanType().optional(),
+    serviceKind: stringType(),
+    serviceConfig: recordType(anyType()),
+    requiredApprovalTags: arrayType(stringType()),
+    serviceKindConfigurationId: stringType().optional(),
+    resourceKind: stringType().optional()
+  });
+  ((ApprovalSettings$) => {
+    ApprovalSettings$.inboundSchema = ApprovalSettings$inboundSchema;
+    ApprovalSettings$.outboundSchema = ApprovalSettings$outboundSchema;
+  })(ApprovalSettings$ ||= {});
+});
+
+// src/models/components/hunkrep.ts
+var HunkRep$inboundSchema, HunkRep$outboundSchema, HunkRep$;
+var init_hunkrep = __esm(() => {
+  init_esm();
+  HunkRep$inboundSchema = objectType({
+    startingLineNumber: numberType().int(),
+    lines: stringType().optional(),
+    projKey: stringType().optional(),
+    flagKey: stringType().optional(),
+    aliases: arrayType(stringType()).optional()
+  });
+  HunkRep$outboundSchema = objectType({
+    startingLineNumber: numberType().int(),
+    lines: stringType().optional(),
+    projKey: stringType().optional(),
+    flagKey: stringType().optional(),
+    aliases: arrayType(stringType()).optional()
+  });
+  ((HunkRep$) => {
+    HunkRep$.inboundSchema = HunkRep$inboundSchema;
+    HunkRep$.outboundSchema = HunkRep$outboundSchema;
+  })(HunkRep$ ||= {});
+});
+
+// src/models/components/referencerep.ts
+var ReferenceRep$inboundSchema, ReferenceRep$outboundSchema, ReferenceRep$;
+var init_referencerep = __esm(() => {
+  init_esm();
+  init_hunkrep();
+  ReferenceRep$inboundSchema = objectType({
+    path: stringType(),
+    hint: stringType().optional(),
+    hunks: arrayType(HunkRep$inboundSchema)
+  });
+  ReferenceRep$outboundSchema = objectType({
+    path: stringType(),
+    hint: stringType().optional(),
+    hunks: arrayType(HunkRep$outboundSchema)
+  });
+  ((ReferenceRep$) => {
+    ReferenceRep$.inboundSchema = ReferenceRep$inboundSchema;
+    ReferenceRep$.outboundSchema = ReferenceRep$outboundSchema;
+  })(ReferenceRep$ ||= {});
+});
+
+// src/models/components/branchrep.ts
+var BranchRep$inboundSchema, BranchRep$outboundSchema, BranchRep$;
+var init_branchrep = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_referencerep();
+  BranchRep$inboundSchema = objectType({
+    name: stringType(),
+    head: stringType(),
+    updateSequenceId: numberType().int().optional(),
+    syncTime: numberType().int(),
+    references: arrayType(ReferenceRep$inboundSchema).optional(),
+    _links: recordType(anyType())
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links"
+    });
+  });
+  BranchRep$outboundSchema = objectType({
+    name: stringType(),
+    head: stringType(),
+    updateSequenceId: numberType().int().optional(),
+    syncTime: numberType().int(),
+    references: arrayType(ReferenceRep$outboundSchema).optional(),
+    links: recordType(anyType())
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links"
+    });
+  });
+  ((BranchRep$) => {
+    BranchRep$.inboundSchema = BranchRep$inboundSchema;
+    BranchRep$.outboundSchema = BranchRep$outboundSchema;
+  })(BranchRep$ ||= {});
+});
+
 // src/models/components/clause.ts
 var Clause$inboundSchema, Clause$outboundSchema, Clause$;
 var init_clause = __esm(() => {
@@ -37304,6 +37421,114 @@ var init_defaults = __esm(() => {
   })(Defaults$ ||= {});
 });
 
+// src/models/components/link.ts
+var Link$inboundSchema, Link$outboundSchema, Link$;
+var init_link = __esm(() => {
+  init_esm();
+  Link$inboundSchema = objectType({
+    href: stringType().optional(),
+    type: stringType().optional()
+  });
+  Link$outboundSchema = objectType({
+    href: stringType().optional(),
+    type: stringType().optional()
+  });
+  ((Link$) => {
+    Link$.inboundSchema = Link$inboundSchema;
+    Link$.outboundSchema = Link$outboundSchema;
+  })(Link$ ||= {});
+});
+
+// src/models/components/environment.ts
+var Environment$inboundSchema, Environment$outboundSchema, Environment$;
+var init_environment = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_approvalsettings();
+  init_link();
+  Environment$inboundSchema = objectType({
+    _links: recordType(Link$inboundSchema),
+    _id: stringType(),
+    key: stringType(),
+    name: stringType(),
+    apiKey: stringType(),
+    mobileKey: stringType(),
+    color: stringType(),
+    defaultTtl: numberType().int(),
+    secureMode: booleanType(),
+    defaultTrackEvents: booleanType(),
+    requireComments: booleanType(),
+    confirmChanges: booleanType(),
+    tags: arrayType(stringType()),
+    approvalSettings: ApprovalSettings$inboundSchema.optional(),
+    resourceApprovalSettings: recordType(ApprovalSettings$inboundSchema).optional(),
+    critical: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links",
+      _id: "id"
+    });
+  });
+  Environment$outboundSchema = objectType({
+    links: recordType(Link$outboundSchema),
+    id: stringType(),
+    key: stringType(),
+    name: stringType(),
+    apiKey: stringType(),
+    mobileKey: stringType(),
+    color: stringType(),
+    defaultTtl: numberType().int(),
+    secureMode: booleanType(),
+    defaultTrackEvents: booleanType(),
+    requireComments: booleanType(),
+    confirmChanges: booleanType(),
+    tags: arrayType(stringType()),
+    approvalSettings: ApprovalSettings$outboundSchema.optional(),
+    resourceApprovalSettings: recordType(ApprovalSettings$outboundSchema).optional(),
+    critical: booleanType()
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links",
+      id: "_id"
+    });
+  });
+  ((Environment$) => {
+    Environment$.inboundSchema = Environment$inboundSchema;
+    Environment$.outboundSchema = Environment$outboundSchema;
+  })(Environment$ ||= {});
+});
+
+// src/models/components/environments.ts
+var Environments$inboundSchema, Environments$outboundSchema, Environments$;
+var init_environments = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_environment();
+  init_link();
+  Environments$inboundSchema = objectType({
+    _links: recordType(Link$inboundSchema).optional(),
+    totalCount: numberType().int().optional(),
+    items: arrayType(Environment$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links"
+    });
+  });
+  Environments$outboundSchema = objectType({
+    links: recordType(Link$outboundSchema).optional(),
+    totalCount: numberType().int().optional(),
+    items: arrayType(Environment$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links"
+    });
+  });
+  ((Environments$) => {
+    Environments$.inboundSchema = Environments$inboundSchema;
+    Environments$.outboundSchema = Environments$outboundSchema;
+  })(Environments$ ||= {});
+});
+
 // src/models/components/experimentallocationrep.ts
 var ExperimentAllocationRep$inboundSchema, ExperimentAllocationRep$outboundSchema, ExperimentAllocationRep$;
 var init_experimentallocationrep = __esm(() => {
@@ -37398,24 +37623,6 @@ var init_filter = __esm(() => {
   })(Filter$ ||= {});
 });
 
-// src/models/components/link.ts
-var Link$inboundSchema, Link$outboundSchema, Link$;
-var init_link = __esm(() => {
-  init_esm();
-  Link$inboundSchema = objectType({
-    href: stringType().optional(),
-    type: stringType().optional()
-  });
-  Link$outboundSchema = objectType({
-    href: stringType().optional(),
-    type: stringType().optional()
-  });
-  ((Link$) => {
-    Link$.inboundSchema = Link$inboundSchema;
-    Link$.outboundSchema = Link$outboundSchema;
-  })(Link$ ||= {});
-});
-
 // src/models/components/membersummary.ts
 var MemberSummary$inboundSchema, MemberSummary$outboundSchema, MemberSummary$;
 var init_membersummary = __esm(() => {
@@ -38311,6 +38518,69 @@ var init_featureflags = __esm(() => {
   })(FeatureFlags$ ||= {});
 });
 
+// src/models/components/featureflagstatus.ts
+var Name, Name$inboundSchema, Name$outboundSchema, Name$, FeatureFlagStatus$inboundSchema, FeatureFlagStatus$outboundSchema, FeatureFlagStatus$;
+var init_featureflagstatus = __esm(() => {
+  init_esm();
+  Name = {
+    New: "new",
+    Inactive: "inactive",
+    Active: "active",
+    Launched: "launched"
+  };
+  Name$inboundSchema = nativeEnumType(Name);
+  Name$outboundSchema = Name$inboundSchema;
+  ((Name$) => {
+    Name$.inboundSchema = Name$inboundSchema;
+    Name$.outboundSchema = Name$outboundSchema;
+  })(Name$ ||= {});
+  FeatureFlagStatus$inboundSchema = objectType({
+    name: Name$inboundSchema,
+    lastRequested: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
+    default: anyType().optional()
+  });
+  FeatureFlagStatus$outboundSchema = objectType({
+    name: Name$outboundSchema,
+    lastRequested: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
+    default: anyType().optional()
+  });
+  ((FeatureFlagStatus$) => {
+    FeatureFlagStatus$.inboundSchema = FeatureFlagStatus$inboundSchema;
+    FeatureFlagStatus$.outboundSchema = FeatureFlagStatus$outboundSchema;
+  })(FeatureFlagStatus$ ||= {});
+});
+
+// src/models/components/featureflagstatusacrossenvironments.ts
+var FeatureFlagStatusAcrossEnvironments$inboundSchema, FeatureFlagStatusAcrossEnvironments$outboundSchema, FeatureFlagStatusAcrossEnvironments$;
+var init_featureflagstatusacrossenvironments = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_featureflagstatus();
+  init_link();
+  FeatureFlagStatusAcrossEnvironments$inboundSchema = objectType({
+    environments: recordType(FeatureFlagStatus$inboundSchema),
+    key: stringType(),
+    _links: recordType(Link$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links"
+    });
+  });
+  FeatureFlagStatusAcrossEnvironments$outboundSchema = objectType({
+    environments: recordType(FeatureFlagStatus$outboundSchema),
+    key: stringType(),
+    links: recordType(Link$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links"
+    });
+  });
+  ((FeatureFlagStatusAcrossEnvironments$) => {
+    FeatureFlagStatusAcrossEnvironments$.inboundSchema = FeatureFlagStatusAcrossEnvironments$inboundSchema;
+    FeatureFlagStatusAcrossEnvironments$.outboundSchema = FeatureFlagStatusAcrossEnvironments$outboundSchema;
+  })(FeatureFlagStatusAcrossEnvironments$ ||= {});
+});
+
 // src/models/components/patchoperation.ts
 var PatchOperation$inboundSchema, PatchOperation$outboundSchema, PatchOperation$;
 var init_patchoperation = __esm(() => {
@@ -38350,6 +38620,96 @@ var init_patchwithcomment = __esm(() => {
   })(PatchWithComment$ ||= {});
 });
 
+// src/models/components/repositoryrep.ts
+var RepositoryRepType, RepositoryRepType$inboundSchema, RepositoryRepType$outboundSchema, RepositoryRepType$, RepositoryRep$inboundSchema, RepositoryRep$outboundSchema, RepositoryRep$;
+var init_repositoryrep = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_access();
+  init_branchrep();
+  RepositoryRepType = {
+    Bitbucket: "bitbucket",
+    Custom: "custom",
+    Github: "github",
+    Gitlab: "gitlab"
+  };
+  RepositoryRepType$inboundSchema = nativeEnumType(RepositoryRepType);
+  RepositoryRepType$outboundSchema = RepositoryRepType$inboundSchema;
+  ((RepositoryRepType$) => {
+    RepositoryRepType$.inboundSchema = RepositoryRepType$inboundSchema;
+    RepositoryRepType$.outboundSchema = RepositoryRepType$outboundSchema;
+  })(RepositoryRepType$ ||= {});
+  RepositoryRep$inboundSchema = objectType({
+    name: stringType(),
+    sourceLink: stringType().optional(),
+    commitUrlTemplate: stringType().optional(),
+    hunkUrlTemplate: stringType().optional(),
+    type: RepositoryRepType$inboundSchema,
+    defaultBranch: stringType(),
+    enabled: booleanType(),
+    version: numberType().int(),
+    branches: arrayType(BranchRep$inboundSchema).optional(),
+    _links: recordType(anyType()),
+    _access: Access$inboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links",
+      _access: "access"
+    });
+  });
+  RepositoryRep$outboundSchema = objectType({
+    name: stringType(),
+    sourceLink: stringType().optional(),
+    commitUrlTemplate: stringType().optional(),
+    hunkUrlTemplate: stringType().optional(),
+    type: RepositoryRepType$outboundSchema,
+    defaultBranch: stringType(),
+    enabled: booleanType(),
+    version: numberType().int(),
+    branches: arrayType(BranchRep$outboundSchema).optional(),
+    links: recordType(anyType()),
+    access: Access$outboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links",
+      access: "_access"
+    });
+  });
+  ((RepositoryRep$) => {
+    RepositoryRep$.inboundSchema = RepositoryRep$inboundSchema;
+    RepositoryRep$.outboundSchema = RepositoryRep$outboundSchema;
+  })(RepositoryRep$ ||= {});
+});
+
+// src/models/components/repositorycollectionrep.ts
+var RepositoryCollectionRep$inboundSchema, RepositoryCollectionRep$outboundSchema, RepositoryCollectionRep$;
+var init_repositorycollectionrep = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_link();
+  init_repositoryrep();
+  RepositoryCollectionRep$inboundSchema = objectType({
+    _links: recordType(Link$inboundSchema),
+    items: arrayType(RepositoryRep$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      _links: "links"
+    });
+  });
+  RepositoryCollectionRep$outboundSchema = objectType({
+    links: recordType(Link$outboundSchema),
+    items: arrayType(RepositoryRep$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      links: "_links"
+    });
+  });
+  ((RepositoryCollectionRep$) => {
+    RepositoryCollectionRep$.inboundSchema = RepositoryCollectionRep$inboundSchema;
+    RepositoryCollectionRep$.outboundSchema = RepositoryCollectionRep$outboundSchema;
+  })(RepositoryCollectionRep$ ||= {});
+});
+
 // src/models/components/security.ts
 var Security$inboundSchema, Security$outboundSchema, Security$;
 var init_security2 = __esm(() => {
@@ -38420,12 +38780,16 @@ var init_components = __esm(() => {
   init_aiconfigvariationpatch();
   init_aiconfigvariationpost();
   init_aiconfigvariationsresponse();
+  init_approvalsettings();
+  init_branchrep();
   init_clause();
   init_clientsideavailability();
   init_clientsideavailabilitypost();
   init_corelink();
   init_customproperty();
   init_defaults();
+  init_environment();
+  init_environments();
   init_experimentallocationrep();
   init_experimentenabledperiodrep();
   init_experimentenvironmentsettingrep();
@@ -38434,12 +38798,15 @@ var init_components = __esm(() => {
   init_featureflagbody();
   init_featureflagconfig();
   init_featureflags();
+  init_featureflagstatus();
+  init_featureflagstatusacrossenvironments();
   init_filter();
   init_flagconfigevaluation();
   init_flagconfigmigrationsettingsrep();
   init_flagmigrationsettingsrep();
   init_flagprerequisitepost();
   init_flagsummary();
+  init_hunkrep();
   init_legacyexperimentrep();
   init_link();
   init_maintainerteam();
@@ -38455,6 +38822,9 @@ var init_components = __esm(() => {
   init_patchoperation();
   init_patchwithcomment();
   init_prerequisite();
+  init_referencerep();
+  init_repositorycollectionrep();
+  init_repositoryrep();
   init_rollout();
   init_rule();
   init_security2();
@@ -39049,6 +39419,30 @@ var init_getaiconfigvariation = __esm(() => {
   })(GetAIConfigVariationRequest$ ||= {});
 });
 
+// src/models/operations/getenvironmentsbyproject.ts
+var GetEnvironmentsByProjectRequest$inboundSchema, GetEnvironmentsByProjectRequest$outboundSchema, GetEnvironmentsByProjectRequest$;
+var init_getenvironmentsbyproject = __esm(() => {
+  init_esm();
+  GetEnvironmentsByProjectRequest$inboundSchema = objectType({
+    projectKey: stringType(),
+    limit: numberType().int().optional(),
+    offset: numberType().int().optional(),
+    filter: stringType().optional(),
+    sort: stringType().optional()
+  });
+  GetEnvironmentsByProjectRequest$outboundSchema = objectType({
+    projectKey: stringType(),
+    limit: numberType().int().optional(),
+    offset: numberType().int().optional(),
+    filter: stringType().optional(),
+    sort: stringType().optional()
+  });
+  ((GetEnvironmentsByProjectRequest$) => {
+    GetEnvironmentsByProjectRequest$.inboundSchema = GetEnvironmentsByProjectRequest$inboundSchema;
+    GetEnvironmentsByProjectRequest$.outboundSchema = GetEnvironmentsByProjectRequest$outboundSchema;
+  })(GetEnvironmentsByProjectRequest$ ||= {});
+});
+
 // src/models/operations/getfeatureflag.ts
 var GetFeatureFlagRequest$inboundSchema, GetFeatureFlagRequest$outboundSchema, GetFeatureFlagRequest$;
 var init_getfeatureflag = __esm(() => {
@@ -39107,6 +39501,48 @@ var init_getfeatureflags = __esm(() => {
   })(GetFeatureFlagsRequest$ ||= {});
 });
 
+// src/models/operations/getfeatureflagstatusacrossenvironments.ts
+var GetFeatureFlagStatusAcrossEnvironmentsRequest$inboundSchema, GetFeatureFlagStatusAcrossEnvironmentsRequest$outboundSchema, GetFeatureFlagStatusAcrossEnvironmentsRequest$;
+var init_getfeatureflagstatusacrossenvironments = __esm(() => {
+  init_esm();
+  GetFeatureFlagStatusAcrossEnvironmentsRequest$inboundSchema = objectType({
+    projectKey: stringType(),
+    featureFlagKey: stringType(),
+    env: stringType().optional()
+  });
+  GetFeatureFlagStatusAcrossEnvironmentsRequest$outboundSchema = objectType({
+    projectKey: stringType(),
+    featureFlagKey: stringType(),
+    env: stringType().optional()
+  });
+  ((GetFeatureFlagStatusAcrossEnvironmentsRequest$) => {
+    GetFeatureFlagStatusAcrossEnvironmentsRequest$.inboundSchema = GetFeatureFlagStatusAcrossEnvironmentsRequest$inboundSchema;
+    GetFeatureFlagStatusAcrossEnvironmentsRequest$.outboundSchema = GetFeatureFlagStatusAcrossEnvironmentsRequest$outboundSchema;
+  })(GetFeatureFlagStatusAcrossEnvironmentsRequest$ ||= {});
+});
+
+// src/models/operations/getrepositories.ts
+var GetRepositoriesRequest$inboundSchema, GetRepositoriesRequest$outboundSchema, GetRepositoriesRequest$;
+var init_getrepositories = __esm(() => {
+  init_esm();
+  GetRepositoriesRequest$inboundSchema = objectType({
+    withBranches: stringType().optional(),
+    withReferencesForDefaultBranch: stringType().optional(),
+    projKey: stringType().optional(),
+    flagKey: stringType().optional()
+  });
+  GetRepositoriesRequest$outboundSchema = objectType({
+    withBranches: stringType().optional(),
+    withReferencesForDefaultBranch: stringType().optional(),
+    projKey: stringType().optional(),
+    flagKey: stringType().optional()
+  });
+  ((GetRepositoriesRequest$) => {
+    GetRepositoriesRequest$.inboundSchema = GetRepositoriesRequest$inboundSchema;
+    GetRepositoriesRequest$.outboundSchema = GetRepositoriesRequest$outboundSchema;
+  })(GetRepositoriesRequest$ ||= {});
+});
+
 // src/models/operations/patchaiconfig.ts
 var PatchAIConfigLDAPIVersion, PatchAIConfigLDAPIVersion$inboundSchema, PatchAIConfigLDAPIVersion$outboundSchema, PatchAIConfigLDAPIVersion$, PatchAIConfigRequest$inboundSchema, PatchAIConfigRequest$outboundSchema, PatchAIConfigRequest$;
 var init_patchaiconfig = __esm(() => {
@@ -39393,8 +39829,11 @@ var init_operations = __esm(() => {
   init_getaiconfigs();
   init_getaiconfigtargeting();
   init_getaiconfigvariation();
+  init_getenvironmentsbyproject();
   init_getfeatureflag();
   init_getfeatureflags();
+  init_getfeatureflagstatusacrossenvironments();
+  init_getrepositories();
   init_patchaiconfig();
   init_patchaiconfigtargeting();
   init_patchaiconfigvariation();
@@ -40698,11 +41137,237 @@ var init_aiConfigsUpdateVariation2 = __esm(() => {
   };
 });
 
-// src/funcs/featureFlagsCreate.ts
-function featureFlagsCreate(client, request, options) {
+// src/funcs/codeReferencesListRepositories.ts
+function codeReferencesListRepositories(client, request, options) {
   return new APIPromise($do12(client, request, options));
 }
 async function $do12(client, request, options) {
+  const parsed = safeParse(request, (value) => GetRepositoriesRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/api/v2/code-refs/repositories")();
+  const query = encodeFormQuery({
+    flagKey: payload.flagKey,
+    projKey: payload.projKey,
+    withBranches: payload.withBranches,
+    withReferencesForDefaultBranch: payload.withReferencesForDefaultBranch
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getRepositories",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "429", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, RepositoryCollectionRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(403, ForbiddenErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_codeReferencesListRepositories = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/codeReferencesListRepositories.ts
+var args12, tool$codeReferencesListRepositories;
+var init_codeReferencesListRepositories2 = __esm(() => {
+  init_codeReferencesListRepositories();
+  init_operations();
+  init_tools();
+  args12 = {
+    request: GetRepositoriesRequest$inboundSchema
+  };
+  tool$codeReferencesListRepositories = {
+    name: "get-code-references",
+    description: `Identifies which repositories have code references to a given flag, helping agents determine if they're operating on the correct repository and understand the scope of cleanup (single vs multi-repo).
+`,
+    scopes: ["read"],
+    args: args12,
+    tool: async (client, args13, ctx) => {
+      const [result, apiCall] = await codeReferencesListRepositories(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/environmentsListByProject.ts
+function environmentsListByProject(client, request, options) {
+  return new APIPromise($do13(client, request, options));
+}
+async function $do13(client, request, options) {
+  const parsed = safeParse(request, (value) => GetEnvironmentsByProjectRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    projectKey: encodeSimple("projectKey", payload.projectKey, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v2/projects/{projectKey}/environments")(pathParams);
+  const query = encodeFormQuery({
+    filter: payload.filter,
+    limit: payload.limit,
+    offset: payload.offset,
+    sort: payload.sort
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getEnvironmentsByProject",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["400", "401", "403", "404", "405", "429", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, Environments$inboundSchema), jsonErr(400, InvalidRequestErrorRep$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(403, ForbiddenErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(405, MethodNotAllowedErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_environmentsListByProject = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/environmentsListByProject.ts
+var args13, tool$environmentsListByProject;
+var init_environmentsListByProject2 = __esm(() => {
+  init_environmentsListByProject();
+  init_operations();
+  init_tools();
+  args13 = {
+    request: GetEnvironmentsByProjectRequest$inboundSchema
+  };
+  tool$environmentsListByProject = {
+    name: "get-environments",
+    description: `Identifies which environments exist in a project and determines which are marked as "critical" (production, staging, etc.). Allows agents to programmatically identify critical environments instead of hardcoding assumptions.
+`,
+    scopes: ["read"],
+    args: args13,
+    tool: async (client, args14, ctx) => {
+      const [result, apiCall] = await environmentsListByProject(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/featureFlagsCreate.ts
+function featureFlagsCreate(client, request, options) {
+  return new APIPromise($do14(client, request, options));
+}
+async function $do14(client, request, options) {
   const parsed = safeParse(request, (value) => PostFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40784,12 +41449,12 @@ var init_featureFlagsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsCreate.ts
-var args12, tool$featureFlagsCreate;
+var args14, tool$featureFlagsCreate;
 var init_featureFlagsCreate2 = __esm(() => {
   init_featureFlagsCreate();
   init_operations();
   init_tools();
-  args12 = {
+  args14 = {
     request: PostFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsCreate = {
@@ -40797,9 +41462,9 @@ var init_featureFlagsCreate2 = __esm(() => {
     description: `Creates a new feature flag within a project. AI agents can use this operation to define feature toggles for controlled rollouts, experimentation, or gated features, automating the flag setup process.
 `,
     scopes: ["write"],
-    args: args12,
-    tool: async (client, args13, ctx) => {
-      const [result, apiCall] = await featureFlagsCreate(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args14,
+    tool: async (client, args15, ctx) => {
+      const [result, apiCall] = await featureFlagsCreate(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40814,9 +41479,9 @@ var init_featureFlagsCreate2 = __esm(() => {
 
 // src/funcs/featureFlagsDelete.ts
 function featureFlagsDelete(client, request, options) {
-  return new APIPromise($do13(client, request, options));
+  return new APIPromise($do15(client, request, options));
 }
-async function $do13(client, request, options) {
+async function $do15(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -40897,12 +41562,12 @@ var init_featureFlagsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsDelete.ts
-var args13, tool$featureFlagsDelete;
+var args15, tool$featureFlagsDelete;
 var init_featureFlagsDelete2 = __esm(() => {
   init_featureFlagsDelete();
   init_operations();
   init_tools();
-  args13 = {
+  args15 = {
     request: DeleteFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsDelete = {
@@ -40910,9 +41575,9 @@ var init_featureFlagsDelete2 = __esm(() => {
     description: `Removes a feature flag from the project. Used by AI agents to clean up deprecated toggles that are no longer in use, improving system hygiene and maintainability.
 `,
     scopes: ["write"],
-    args: args13,
-    tool: async (client, args14, ctx) => {
-      const [result, apiCall] = await featureFlagsDelete(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args15,
+    tool: async (client, args16, ctx) => {
+      const [result, apiCall] = await featureFlagsDelete(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -40926,9 +41591,9 @@ var init_featureFlagsDelete2 = __esm(() => {
 
 // src/funcs/featureFlagsGet.ts
 function featureFlagsGet(client, request, options) {
-  return new APIPromise($do14(client, request, options));
+  return new APIPromise($do16(client, request, options));
 }
-async function $do14(client, request, options) {
+async function $do16(client, request, options) {
   const parsed = safeParse(request, (value) => GetFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41014,12 +41679,12 @@ var init_featureFlagsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsGet.ts
-var args14, tool$featureFlagsGet;
+var args16, tool$featureFlagsGet;
 var init_featureFlagsGet2 = __esm(() => {
   init_featureFlagsGet();
   init_operations();
   init_tools();
-  args14 = {
+  args16 = {
     request: GetFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsGet = {
@@ -41027,9 +41692,126 @@ var init_featureFlagsGet2 = __esm(() => {
     description: `Fetches the full configuration for a specific feature flag, including environments, variations, and targeting rules. Useful for agents auditing or managing specific feature toggles in a detailed, contextual manner.
 `,
     scopes: ["read"],
-    args: args14,
-    tool: async (client, args15, ctx) => {
-      const [result, apiCall] = await featureFlagsGet(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args16,
+    tool: async (client, args17, ctx) => {
+      const [result, apiCall] = await featureFlagsGet(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/featureFlagsGetStatus.ts
+function featureFlagsGetStatus(client, request, options) {
+  return new APIPromise($do17(client, request, options));
+}
+async function $do17(client, request, options) {
+  const parsed = safeParse(request, (value) => GetFeatureFlagStatusAcrossEnvironmentsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    featureFlagKey: encodeSimple("featureFlagKey", payload.featureFlagKey, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    projectKey: encodeSimple("projectKey", payload.projectKey, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/api/v2/flag-status/{projectKey}/{featureFlagKey}")(pathParams);
+  const query = encodeFormQuery({
+    env: payload.env
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getFeatureFlagStatusAcrossEnvironments",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "404", "429", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, FeatureFlagStatusAcrossEnvironments$inboundSchema), jsonErr(401, UnauthorizedErrorRep$inboundSchema), jsonErr(403, ForbiddenErrorRep$inboundSchema), jsonErr(404, NotFoundErrorRep$inboundSchema), jsonErr(429, RateLimitedErrorRep$inboundSchema), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_featureFlagsGetStatus = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/featureFlagsGetStatus.ts
+var args17, tool$featureFlagsGetStatus;
+var init_featureFlagsGetStatus2 = __esm(() => {
+  init_featureFlagsGetStatus();
+  init_operations();
+  init_tools();
+  args17 = {
+    request: GetFeatureFlagStatusAcrossEnvironmentsRequest$inboundSchema
+  };
+  tool$featureFlagsGetStatus = {
+    name: "get-flag-status-across-environments",
+    description: `Returns lifecycle status (new, active, inactive, launched) based on actual usage patterns, evaluation counts, and configuration stability. This is the key intelligence for removal readiness assessment.
+`,
+    scopes: ["read"],
+    args: args17,
+    tool: async (client, args18, ctx) => {
+      const [result, apiCall] = await featureFlagsGetStatus(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41044,9 +41826,9 @@ var init_featureFlagsGet2 = __esm(() => {
 
 // src/funcs/featureFlagsList.ts
 function featureFlagsList(client, request, options) {
-  return new APIPromise($do15(client, request, options));
+  return new APIPromise($do18(client, request, options));
 }
-async function $do15(client, request, options) {
+async function $do18(client, request, options) {
   const parsed = safeParse(request, (value) => GetFeatureFlagsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41136,12 +41918,12 @@ var init_featureFlagsList = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsList.ts
-var args15, tool$featureFlagsList;
+var args18, tool$featureFlagsList;
 var init_featureFlagsList2 = __esm(() => {
   init_featureFlagsList();
   init_operations();
   init_tools();
-  args15 = {
+  args18 = {
     request: GetFeatureFlagsRequest$inboundSchema
   };
   tool$featureFlagsList = {
@@ -41149,9 +41931,9 @@ var init_featureFlagsList2 = __esm(() => {
     description: `Retrieves all feature flags within a project, including metadata and targeting rules. Enables AI agents to enumerate existing flags for inspection, configuration analysis, or generating flag usage reports across environments.
 `,
     scopes: ["read"],
-    args: args15,
-    tool: async (client, args16, ctx) => {
-      const [result, apiCall] = await featureFlagsList(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args18,
+    tool: async (client, args19, ctx) => {
+      const [result, apiCall] = await featureFlagsList(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41166,9 +41948,9 @@ var init_featureFlagsList2 = __esm(() => {
 
 // src/funcs/featureFlagsPatch.ts
 function featureFlagsPatch(client, request, options) {
-  return new APIPromise($do16(client, request, options));
+  return new APIPromise($do19(client, request, options));
 }
-async function $do16(client, request, options) {
+async function $do19(client, request, options) {
   const parsed = safeParse(request, (value) => PatchFeatureFlagRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -41254,12 +42036,12 @@ var init_featureFlagsPatch = __esm(() => {
 });
 
 // src/mcp-server/tools/featureFlagsPatch.ts
-var args16, tool$featureFlagsPatch;
+var args19, tool$featureFlagsPatch;
 var init_featureFlagsPatch2 = __esm(() => {
   init_featureFlagsPatch();
   init_operations();
   init_tools();
-  args16 = {
+  args19 = {
     request: PatchFeatureFlagRequest$inboundSchema
   };
   tool$featureFlagsPatch = {
@@ -41267,9 +42049,9 @@ var init_featureFlagsPatch2 = __esm(() => {
     description: `Updates the configuration of an existing feature flag. Enables agents to change targeting rules, modify variations, or adapt rollout strategies dynamically in response to user behavior or experiment results.
 `,
     scopes: ["write"],
-    args: args16,
-    tool: async (client, args17, ctx) => {
-      const [result, apiCall] = await featureFlagsPatch(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args19,
+    tool: async (client, args20, ctx) => {
+      const [result, apiCall] = await featureFlagsPatch(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -41286,7 +42068,7 @@ var init_featureFlagsPatch2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "LaunchDarkly",
-    version: "0.4.0"
+    version: "0.4.2"
   });
   const client = new LaunchDarklyCore({
     apiKey: deps.apiKey,
@@ -41300,11 +42082,14 @@ function createMCPServer(deps) {
   const resourceTemplate = createRegisterResourceTemplate(deps.logger, server, client, scopes);
   const prompt = createRegisterPrompt(deps.logger, server, client, scopes);
   const register = { tool, resource, resourceTemplate, prompt };
+  tool(tool$codeReferencesListRepositories);
+  tool(tool$featureFlagsGetStatus);
   tool(tool$featureFlagsList);
   tool(tool$featureFlagsCreate);
   tool(tool$featureFlagsGet);
   tool(tool$featureFlagsPatch);
   tool(tool$featureFlagsDelete);
+  tool(tool$environmentsListByProject);
   tool(tool$aiConfigsGetTargeting);
   tool(tool$aiConfigsUpdateTargeting);
   tool(tool$aiConfigsList);
@@ -41334,9 +42119,12 @@ var init_server2 = __esm(() => {
   init_aiConfigsUpdate2();
   init_aiConfigsUpdateTargeting2();
   init_aiConfigsUpdateVariation2();
+  init_codeReferencesListRepositories2();
+  init_environmentsListByProject2();
   init_featureFlagsCreate2();
   init_featureFlagsDelete2();
   init_featureFlagsGet2();
+  init_featureFlagsGetStatus2();
   init_featureFlagsList2();
   init_featureFlagsPatch2();
 });
@@ -42530,7 +43318,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.4.0"
+    currentVersion: "0.4.2"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -42538,5 +43326,5 @@ export {
   app
 };
 
-//# debugId=8688EE4AC588B59B64756E2164756E21
+//# debugId=B9F134BD449EA7F964756E2164756E21
 //# sourceMappingURL=mcp-server.js.map