@pagopa/dx-savemoney 0.2.6 → 0.3.1

package/src/azure/analyzers/__tests__/advisor.test.ts

@@ -0,0 +1,367 @@
+/**
+ * Tests for the Azure Advisor subscription-level analyzer.
+ *
+ * We never touch a real Azure subscription: the analyzer is constructed
+ * with an injected client factory that returns a fake exposing only the
+ * `recommendations.list()` async iterator the analyzer relies on.
+ */
+
+import type { TokenCredential } from "@azure/identity";
+
+import { describe, expect, it } from "vitest";
+
+import type { SubscriptionContext } from "../subscription.js";
+
+import { createAdvisorAnalyzer } from "../advisor.js";
+
+// The analyzer only consumes the fields below; using a structural mock
+// keeps the test independent from the (rather verbose) SDK shape.
+type RecLike = {
+  category?: string;
+  extendedProperties?: Record<string, string>;
+  id?: string;
+  impact?: string;
+  recommendationTypeId?: string;
+  resourceMetadata?: { resourceId?: string };
+  shortDescription?: { problem?: string; solution?: string };
+};
+
+function makeCtx(): SubscriptionContext {
+  const credential: TokenCredential = {
+    getToken: async () => null,
+  };
+  return {
+    credential,
+    subscriptionId: "00000000-0000-0000-0000-000000000000",
+    verbose: false,
+  };
+}
+
+// Reusable ARM-style resource IDs used across tests
+const RID1 =
+  "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm-1";
+const RID2 =
+  "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm-2";
+
+function makeFakeClient(recs: RecLike[]) {
+  return {
+    recommendations: {
+      async *list() {
+        for (const r of recs) yield r;
+      },
+    },
+  };
+}
+
+describe("createAdvisorAnalyzer", () => {
+  it("exposes a stable id", () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () => makeFakeClient([]),
+    });
+    expect(analyzer.id).toBe("azure.advisor");
+  });
+
+  it("returns no findings for an empty list", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () => makeFakeClient([]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings).toEqual([]);
+  });
+});
+
+describe("createAdvisorAnalyzer — recommendation mapping", () => {
+  it("maps a Cost recommendation to a Finding with savings", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            extendedProperties: {
+              savingsAmount: "42.50",
+              savingsCurrency: "EUR",
+            },
+            impact: "High",
+            recommendationTypeId: "right-size-vm",
+            resourceMetadata: {
+              resourceId:
+                "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm",
+            },
+            shortDescription: {
+              problem: "Right-size your VM",
+              solution: "Switch to a smaller SKU",
+            },
+          },
+        ]),
+    });
+
+    const findings = await analyzer.analyze(makeCtx());
+
+    expect(findings).toHaveLength(1);
+    const finding = findings[0];
+    expect(finding.source).toBe("advisor");
+    expect(finding.code).toBe("advisor.right-size-vm");
+    expect(finding.severity).toBe("high");
+    expect(finding.category).toBe("cost");
+    expect(finding.estimatedMonthlySavings).toEqual({
+      amount: 42.5,
+      currency: "EUR",
+    });
+    expect(finding.recommendedAction).toBe("Switch to a smaller SKU");
+    expect(finding.reason).toBe("Right-size your VM.");
+    expect(finding.resourceId).toBe(
+      "/subscriptions/sub1/resourceGroups/rg1/providers/Microsoft.Compute/virtualMachines/vm",
+    );
+  });
+
+  it("maps `Medium` impact to severity `medium`", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            impact: "Medium",
+            recommendationTypeId: "x",
+            resourceMetadata: { resourceId: RID1 },
+            shortDescription: { problem: "p" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings[0].severity).toBe("medium");
+  });
+
+  it("falls back to `low` for unknown impact values", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            impact: "Bogus",
+            recommendationTypeId: "x",
+            resourceMetadata: { resourceId: RID1 },
+            shortDescription: { problem: "p" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings[0].severity).toBe("low");
+  });
+});
+
+describe("createAdvisorAnalyzer — savings parsing", () => {
+  it("omits estimatedMonthlySavings when savingsAmount is missing", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            impact: "Low",
+            recommendationTypeId: "x",
+            resourceMetadata: { resourceId: RID1 },
+            shortDescription: { problem: "p" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings[0].estimatedMonthlySavings).toBeUndefined();
+  });
+
+  it("omits estimatedMonthlySavings when savingsAmount is not a number", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            extendedProperties: { savingsAmount: "n/a" },
+            impact: "Low",
+            recommendationTypeId: "x",
+            resourceMetadata: { resourceId: RID1 },
+            shortDescription: { problem: "p" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings[0].estimatedMonthlySavings).toBeUndefined();
+  });
+
+  it("defaults the currency to USD when only savingsAmount is present", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            extendedProperties: { savingsAmount: "10" },
+            impact: "Low",
+            recommendationTypeId: "x",
+            resourceMetadata: { resourceId: RID1 },
+            shortDescription: { problem: "p" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings[0].estimatedMonthlySavings).toEqual({
+      amount: 10,
+      currency: "USD",
+    });
+  });
+});
+
+describe("createAdvisorAnalyzer — filtering", () => {
+  it("skips non-Cost recommendations", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Security",
+            impact: "High",
+            recommendationTypeId: "x",
+            resourceMetadata: { resourceId: RID1 },
+            shortDescription: { problem: "p" },
+          },
+          {
+            category: "Cost",
+            impact: "Low",
+            recommendationTypeId: "y",
+            resourceMetadata: { resourceId: RID2 },
+            shortDescription: { problem: "p" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings).toHaveLength(1);
+    expect(findings[0].code).toBe("advisor.y");
+  });
+
+  it("attributes subscription as fallback resource when resourceId is absent", async () => {
+    const ctx = makeCtx();
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            impact: "Low",
+            recommendationTypeId: "x",
+            resourceMetadata: {},
+            shortDescription: { problem: "p" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(ctx);
+    expect(findings).toHaveLength(1);
+    expect(findings[0].resourceId).toBe(`/subscriptions/${ctx.subscriptionId}`);
+  });
+
+  it("includes subscription-scoped recommendations using their own resource ID", async () => {
+    const SUB_URI = "/subscriptions/00000000-0000-0000-0000-000000000000";
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            impact: "High",
+            recommendationTypeId: "reserved-instance",
+            resourceMetadata: { resourceId: SUB_URI },
+            shortDescription: { problem: "Consider reserved instances" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings).toHaveLength(1);
+    expect(findings[0].resourceId).toBe(SUB_URI);
+    expect(findings[0].severity).toBe("high");
+  });
+
+  it("aggregates subscription-scoped findings with the same recommendationTypeId", async () => {
+    const SUB_URI = "/subscriptions/00000000-0000-0000-0000-000000000000";
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            extendedProperties: {
+              savingsAmount: "121",
+              savingsCurrency: "EUR",
+            },
+            id: "/subscriptions/sub1/advisorRecommendations/r1",
+            impact: "High",
+            recommendationTypeId: "postgresql-ri",
+            resourceMetadata: { resourceId: SUB_URI },
+            shortDescription: {
+              problem: "Consider PostgreSQL reserved instance",
+            },
+          },
+          {
+            category: "Cost",
+            extendedProperties: { savingsAmount: "71", savingsCurrency: "EUR" },
+            id: "/subscriptions/sub1/advisorRecommendations/r2",
+            impact: "High",
+            recommendationTypeId: "postgresql-ri",
+            resourceMetadata: { resourceId: SUB_URI },
+            shortDescription: {
+              problem: "Consider PostgreSQL reserved instance",
+            },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    // Two API entries with the same type → one aggregated finding.
+    expect(findings).toHaveLength(1);
+    expect(findings[0].code).toBe("advisor.postgresql-ri");
+    expect(findings[0].estimatedMonthlySavings).toEqual({
+      amount: 121,
+      currency: "EUR",
+    });
+    expect(findings[0].reason).toContain("2 options");
+  });
+
+  it("deduplicates subscription-scoped entries with the same recommendation ARM ID", async () => {
+    const SUB_URI = "/subscriptions/00000000-0000-0000-0000-000000000000";
+    const dupId =
+      "/subscriptions/sub1/providers/microsoft.advisor/recommendations/dup";
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            extendedProperties: { savingsAmount: "50", savingsCurrency: "EUR" },
+            id: dupId,
+            impact: "High",
+            recommendationTypeId: "vm-ri",
+            resourceMetadata: { resourceId: SUB_URI },
+            shortDescription: { problem: "Buy VM reserved instance" },
+          },
+          {
+            // Same ARM ID returned again by the API — should be counted only once.
+            category: "Cost",
+            extendedProperties: { savingsAmount: "50", savingsCurrency: "EUR" },
+            id: dupId,
+            impact: "High",
+            recommendationTypeId: "vm-ri",
+            resourceMetadata: { resourceId: SUB_URI },
+            shortDescription: { problem: "Buy VM reserved instance" },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings).toHaveLength(1);
+    // Savings must NOT be doubled.
+    expect(findings[0].estimatedMonthlySavings?.amount).toBe(50);
+  });
+
+  it("uses a fallback reason when shortDescription is missing", async () => {
+    const analyzer = createAdvisorAnalyzer({
+      build: () =>
+        makeFakeClient([
+          {
+            category: "Cost",
+            impact: "Low",
+            recommendationTypeId: "x",
+            resourceMetadata: { resourceId: RID1 },
+          },
+        ]),
+    });
+    const findings = await analyzer.analyze(makeCtx());
+    expect(findings[0].reason).toBe("Azure Advisor cost recommendation.");
+  });
+});

package/src/azure/analyzers/advisor.ts

@@ -0,0 +1,324 @@
+/**
+ * Azure Advisor analyzer.
+ *
+ * Fetches all `Cost` recommendations for the target subscription via the
+ * `@azure/arm-advisor` SDK and normalises them into the unified `Finding`
+ * model.
+ *
+ * ## Two kinds of Advisor cost recommendations
+ *
+ * ### Resource-specific (resourceMetadata.resourceId contains /providers/)
+ * Recommendations about a particular Azure resource (e.g. "right-size this
+ * VM"). Each is emitted as a separate Finding so it appears next to the
+ * resource in the per-resource section of the report. `enrichReason` adds
+ * SKU / region / term context from `extendedProperties` so findings for
+ * the same recommendation type on different resources are distinguishable.
+ *
+ * ### Subscription-scoped (no resourceId, or resourceId without /providers/)
+ * Reserved Instance and Savings Plan recommendations. The Advisor API
+ * returns **one entry per qualifying combination** (term, scope, quantity,
+ * etc.) but the Azure Portal **groups them by `recommendationTypeId`** and
+ * shows a single entry for the best option — matching the mental model
+ * a user has when deciding whether to buy a commitment.
+ *
+ * Different amounts within the same `recommendationTypeId` represent
+ * **mutually exclusive purchase options** (e.g. different DB sizes or
+ * quantities); the user would choose one, not buy all. We therefore report
+ * the **maximum** savings amount across all unique configurations, matching
+ * the portal's behaviour. Scope variants (Shared / Single / ResourceGroup)
+ * that carry the same amount are deduplicated so they do not count more
+ * than once. True duplicates — recommendations with the same ARM ID —
+ * are also removed before taking the maximum.
+ */
+
+import { AdvisorManagementClient } from "@azure/arm-advisor";
+import { getLogger } from "@logtape/logtape";
+
+import type { Finding } from "../../finding.js";
+import type { CostRisk } from "../../types.js";
+import type {
+  SubscriptionAnalyzer,
+  SubscriptionContext,
+} from "./subscription.js";
+
+/** Minimal client shape used by the analyzer (and injectable in tests). */
+type AdvisorClientLike = {
+  recommendations: {
+    list(options?: { filter?: string }): AsyncIterable<RecommendationInfo>;
+  };
+};
+
+/** Minimal shape of a recommendation entry needed by the helpers. */
+type RecommendationInfo = {
+  category?: string;
+  extendedProperties?: Record<string, unknown>;
+  id?: string;
+  impact?: string;
+  recommendationTypeId?: string;
+  resourceMetadata?: { resourceId?: string };
+  shortDescription?: { problem?: string; solution?: string };
+};
+
+/** Accumulator for subscription-scoped recommendations grouped by type. */
+type SubGroup = {
+  /** Best (maximum) monthly savings among all deduplicated options in this group. */
+  bestAmount: number;
+  /** Number of distinct savings configurations aggregated (unique amounts). */
+  count: number;
+  /** ISO 4217 currency code of the first recommendation in this group. */
+  currency: string;
+  /** Prototype Finding shared by all recommendations in this group. */
+  proto: Omit<Finding, "estimatedMonthlySavings">;
+  /** ARM IDs of recommendations already counted — deduplicates true API duplicates. */
+  recIds: Set<string>;
+  /**
+   * `"${amount}"` keys for already-seen savings — deduplicates scope variants.
+   * Advisor returns the same configuration for Shared, Single, and ResourceGroup
+   * scopes all with the same savings amount; we track each amount only once so
+   * we can take the max without double-counting identical scope variants.
+   */
+  uniqueSavingsKeys: Set<string>;
+};
+
+/**
+ * Builds the Advisor subscription-level analyzer.
+ *
+ * @param clientFactory  Optional override to inject a mock client in tests.
+ *                       In production the default factory builds a real
+ *                       `AdvisorManagementClient` from the credential.
+ */
+export function createAdvisorAnalyzer(clientFactory?: {
+  build(
+    credential: SubscriptionContext["credential"],
+    subscriptionId: string,
+  ): AdvisorClientLike;
+}): SubscriptionAnalyzer {
+  const build =
+    clientFactory?.build ??
+    ((credential, subscriptionId) =>
+      new AdvisorManagementClient(credential, subscriptionId));
+
+  return {
+    async analyze(ctx: SubscriptionContext): Promise<Finding[]> {
+      const logger = getLogger(["savemoney", "azure", "advisor"]);
+      const client = build(ctx.credential, ctx.subscriptionId);
+      const resourceFindings: Finding[] = [];
+      const subGroups = new Map<string, SubGroup>();
+
+      for await (const rec of client.recommendations.list({
+        filter: "Category eq 'Cost'",
+      })) {
+        if (rec.category?.toLowerCase() !== "cost") continue;
+        const rawResourceId = rec.resourceMetadata?.resourceId;
+        const props = rec.extendedProperties as
+          | Record<string, string>
+          | undefined;
+        const savings = parseSavings(props);
+        if (rawResourceId && /\/providers\//i.test(rawResourceId)) {
+          resourceFindings.push(
+            buildResourceFinding(rec, savings, props, rawResourceId),
+          );
+        } else {
+          addToSubGroups(subGroups, rec, savings, ctx, logger);
+        }
+      }
+
+      const findings = [...resourceFindings, ...flushSubGroups(subGroups)];
+      logger.info(
+        `Advisor: ${findings.length} cost finding(s) for ${ctx.subscriptionId}` +
+          ` (${resourceFindings.length} resource-specific, ${subGroups.size} subscription-level)`,
+      );
+      return findings;
+    },
+    id: "azure.advisor",
+  };
+}
+
+// ── helpers — extracted to keep `analyze` complexity within linter limits —
+
+function addToSubGroups(
+  subGroups: Map<string, SubGroup>,
+  rec: RecommendationInfo,
+  savings: undefined | { amount: number; currency: string },
+  ctx: SubscriptionContext,
+  logger: ReturnType<typeof getLogger>,
+): void {
+  const typeKey =
+    rec.recommendationTypeId ??
+    `unknown.${rec.shortDescription?.problem ?? ""}`;
+  const existing = subGroups.get(typeKey);
+  if (existing) {
+    updateSubGroup(existing, rec.id ?? "", savings);
+  } else {
+    subGroups.set(typeKey, createSubGroup(rec, typeKey, savings, ctx, logger));
+  }
+}
+
+function buildResourceFinding(
+  rec: RecommendationInfo,
+  savings: undefined | { amount: number; currency: string },
+  props: Record<string, string> | undefined,
+  rawResourceId: string,
+): Finding {
+  const problem =
+    rec.shortDescription?.problem ??
+    rec.shortDescription?.solution ??
+    "Azure Advisor cost recommendation";
+  return {
+    category: "cost",
+    code: `advisor.${rec.recommendationTypeId ?? "unknown"}`,
+    estimatedMonthlySavings: savings,
+    reason: enrichReason(problem, props),
+    recommendedAction: rec.shortDescription?.solution,
+    resourceId: rawResourceId,
+    severity: mapImpact(rec.impact),
+    source: "advisor",
+  };
+}
+
+function createSubGroup(
+  rec: RecommendationInfo,
+  typeKey: string,
+  savings: undefined | { amount: number; currency: string },
+  ctx: SubscriptionContext,
+  logger: ReturnType<typeof getLogger>,
+): SubGroup {
+  const problem =
+    rec.shortDescription?.problem ??
+    rec.shortDescription?.solution ??
+    "Azure Advisor cost recommendation";
+  const reason = problem.endsWith(".") ? problem : `${problem}.`;
+  const rawResourceId = rec.resourceMetadata?.resourceId;
+  const resourceId = rawResourceId ?? `/subscriptions/${ctx.subscriptionId}`;
+  if (!rawResourceId && ctx.verbose) {
+    logger.debug(
+      `Advisor recommendation has no resourceId, attributed to subscription: ${typeKey}`,
+    );
+  }
+  return {
+    bestAmount: savings?.amount ?? 0,
+    count: savings ? 1 : 0,
+    currency: savings?.currency ?? "USD",
+    proto: {
+      category: "cost",
+      code: `advisor.${typeKey}`,
+      reason,
+      recommendedAction: rec.shortDescription?.solution,
+      resourceId,
+      severity: mapImpact(rec.impact),
+      source: "advisor",
+    },
+    recIds: new Set(rec.id ? [rec.id] : []),
+    uniqueSavingsKeys: new Set(savings ? [`${savings.amount}`] : []),
+  };
+}
+
+/**
+ * Appends discriminating context (SKU, region, term, scope, …) to the
+ * Advisor short description so visually-duplicated reasons can be told
+ * apart. RI / Savings Plan recommendations in particular return the same
+ * `problem` string for every SKU+region+term combination, which made the
+ * report look like it carried duplicated rows. Each call stays a single
+ * Finding — we do NOT deduplicate, because every recommendation refers
+ * to a different commitment with its own savings figure.
+ */
+function enrichReason(
+  problem: string,
+  props: Record<string, string> | undefined,
+): string {
+  const base = problem.endsWith(".") ? problem : `${problem}.`;
+  if (!props) return base;
+  const parts: string[] = [];
+  // armSkuName covers VM RIs; productName/serviceType cover SQL/Cosmos/etc.
+  const sku =
+    props.armSkuName ?? props.productName ?? props.serviceType ?? props.sku;
+  if (sku) parts.push(sku);
+  const region = props.region ?? props.location;
+  if (region) parts.push(region);
+  // Normalise term values (P1Y / P3Y / 1_Year / 3_Year) into a compact label.
+  const rawTerm = props.term;
+  if (rawTerm) {
+    const term = /3/.test(rawTerm) ? "3y" : /1/.test(rawTerm) ? "1y" : rawTerm;
+    parts.push(term);
+  }
+  const scope = props.scope;
+  if (scope) parts.push(scope.toLowerCase());
+  const qty = props.displayQuantity ?? props.quantity;
+  if (qty) parts.push(`x${qty}`);
+  if (parts.length === 0) return base;
+  return `${base} (${parts.join(", ")})`;
+}
+
+function flushSubGroups(subGroups: Map<string, SubGroup>): Finding[] {
+  const findings: Finding[] = [];
+  for (const { bestAmount, count, currency, proto } of subGroups.values()) {
+    const estimatedMonthlySavings =
+      bestAmount > 0 ? { amount: bestAmount, currency } : undefined;
+    const reason =
+      count > 1
+        ? proto.reason.replace(/\.$/, ` (${count} options).`)
+        : proto.reason;
+    findings.push({ ...proto, estimatedMonthlySavings, reason });
+  }
+  return findings;
+}
+
+/**
+ * Maps Advisor's `impact` (`High` | `Medium` | `Low`) onto the savemoney
+ * `CostRisk` scale. Falls back to `low` for any unexpected value to keep
+ * the analyzer resilient to future Advisor enum extensions.
+ */
+function mapImpact(impact: string | undefined): CostRisk {
+  switch (impact?.toLowerCase()) {
+    case "high":
+      return "high";
+    case "medium":
+      return "medium";
+    default:
+      return "low";
+  }
+}
+
+/**
+ * Parses the savings amount from Advisor's `extendedProperties`. Advisor
+ * returns it as a string; treat anything non-numeric as "no estimate".
+ */
+function parseSavings(
+  extendedProperties: Record<string, string> | undefined,
+): undefined | { amount: number; currency: string } {
+  if (!extendedProperties) return undefined;
+  const raw = extendedProperties.savingsAmount ?? extendedProperties.savings;
+  if (!raw) return undefined;
+  const amount = Number(raw);
+  if (!Number.isFinite(amount)) return undefined;
+  const currency =
+    extendedProperties.savingsCurrency ?? extendedProperties.currency ?? "USD";
+  return { amount, currency };
+}
+
+function updateSubGroup(
+  group: SubGroup,
+  recId: string,
+  savings: undefined | { amount: number; currency: string },
+): void {
+  if (recId && group.recIds.has(recId)) return; // true API duplicate
+  if (recId) group.recIds.add(recId);
+  if (!savings) return;
+  // Bootstrap currency from the first recommendation that carries savings.
+  // createSubGroup() defaults currency to "USD" when the first entry has no
+  // savings; without this check, later entries with a different currency (e.g.
+  // "EUR") would be silently dropped and no savings would ever be surfaced.
+  if (group.count === 0) {
+    group.currency = savings.currency;
+    group.uniqueSavingsKeys.add(`${savings.amount}`);
+    group.bestAmount = savings.amount;
+    group.count = 1;
+    return;
+  }
+  if (savings.currency !== group.currency) return;
+  const key = `${savings.amount}`;
+  if (group.uniqueSavingsKeys.has(key)) return; // scope variant, already seen
+  group.uniqueSavingsKeys.add(key);
+  group.bestAmount = Math.max(group.bestAmount, savings.amount);
+  group.count++;
+}

package/src/azure/analyzers/index.ts

@@ -2,5 +2,13 @@
  * Re-exports for the Azure analyzer plugin layer.
  */
 
-export { createDefaultAnalyzers } from "./registry.js";
+export { createAdvisorAnalyzer } from "./advisor.js";
+export {
+  createDefaultAnalyzers,
+  createDefaultSubscriptionAnalyzers,
+} from "./registry.js";
+export type {
+  SubscriptionAnalyzer,
+  SubscriptionContext,
+} from "./subscription.js";
 export type { Analyzer, AnalyzerContext, AzureClients } from "./types.js";