@pagopa/dx-savemoney 0.1.1

package/src/azure/resources/storage.ts

@@ -0,0 +1,67 @@
+/**
+ * Azure Storage Account analysis
+ */
+
+import type { MonitorClient } from "@azure/arm-monitor";
+
+import * as armResources from "@azure/arm-resources";
+
+import type { AnalysisResult } from "../../types.js";
+
+import {
+  getMetric,
+  verboseLog,
+  verboseLogAnalysisResult,
+  verboseLogResourceStart,
+} from "../utils.js";
+
+/**
+ * Analyzes an Azure Storage Account for potential cost optimization.
+ *
+ * @param resource - The Azure resource object
+ * @param monitorClient - Azure Monitor client for metrics
+ * @param timespanDays - Number of days to analyze metrics
+ * @returns Analysis result with cost risk and reason
+ */
+export async function analyzeStorageAccount(
+  resource: armResources.GenericResource,
+  monitorClient: MonitorClient,
+  timespanDays: number,
+  verbose = false,
+): Promise<AnalysisResult> {
+  verboseLogResourceStart(
+    verbose,
+    resource.name || "unknown",
+    "Storage Account (microsoft.storage/storageaccounts)",
+  );
+  verboseLog(verbose, "Resource details:", resource);
+
+  const costRisk: "high" | "low" | "medium" = "medium";
+  if (!resource.id) {
+    return {
+      costRisk,
+      reason: "Resource ID is missing.",
+      suspectedUnused: false,
+    };
+  }
+  const transactions = await getMetric(
+    monitorClient,
+    resource.id,
+    "Transactions",
+    "Total",
+    timespanDays,
+  );
+  if (transactions !== null && transactions < 100) {
+    // Very low transactions
+    const result = {
+      costRisk,
+      reason: `Very low transaction count (${transactions}). `,
+      suspectedUnused: true,
+    };
+    verboseLogAnalysisResult(verbose, result);
+    return result;
+  }
+  const result = { costRisk, reason: "", suspectedUnused: false };
+  verboseLogAnalysisResult(verbose, result);
+  return result;
+}

package/src/azure/resources/vm.ts

@@ -0,0 +1,129 @@
+/**
+ * Azure Virtual Machine analysis
+ */
+
+import type { ComputeManagementClient } from "@azure/arm-compute";
+import type { MonitorClient } from "@azure/arm-monitor";
+
+import * as armResources from "@azure/arm-resources";
+import { getLogger } from "@logtape/logtape";
+
+import type { AnalysisResult } from "../../types.js";
+
+import {
+  getMetric,
+  verboseLog,
+  verboseLogAnalysisResult,
+  verboseLogResourceStart,
+} from "../utils.js";
+
+/**
+ * Analyzes an Azure Virtual Machine for potential cost optimization.
+ *
+ * @param resource - The Azure resource object
+ * @param monitorClient - Azure Monitor client for fetching metrics
+ * @param computeClient - Azure Compute client for VM details
+ * @param timespanDays - Number of days to analyze metrics
+ * @param verbose - Whether verbose logging is enabled
+ * @returns Analysis result with cost risk and reason
+ */
+export async function analyzeVM(
+  resource: armResources.GenericResource,
+  monitorClient: MonitorClient,
+  computeClient: ComputeManagementClient,
+  timespanDays: number,
+  verbose = false,
+): Promise<AnalysisResult> {
+  verboseLogResourceStart(
+    verbose,
+    resource.name || "unknown",
+    "Virtual Machine (microsoft.compute/virtualmachines)",
+  );
+  verboseLog(verbose, "Resource details:", resource);
+
+  const costRisk: "high" | "low" | "medium" = "high";
+  let reason = "";
+
+  if (!resource.id) {
+    return {
+      costRisk,
+      reason: "Resource ID is missing.",
+      suspectedUnused: false,
+    };
+  }
+
+  // Extract resource group and VM name from resource ID
+  const resourceParts = resource.id.split("/");
+  const resourceGroupName = resourceParts[4];
+  const vmName = resourceParts[8];
+
+  try {
+    // Get the actual VM instance view to check power state
+    const instanceView = await computeClient.virtualMachines.instanceView(
+      resourceGroupName,
+      vmName,
+    );
+
+    verboseLog(verbose, "VM Instance View:", instanceView);
+
+    // Check power state from instance view
+    const vmStatus = instanceView.statuses?.find((s: { code?: string }) =>
+      s.code?.startsWith("PowerState/"),
+    );
+
+    if (vmStatus?.code === "PowerState/deallocated") {
+      const result = {
+        costRisk,
+        reason: "VM is deallocated. ",
+        suspectedUnused: true,
+      };
+      verboseLogAnalysisResult(verbose, result);
+      return result;
+    }
+
+    if (vmStatus?.code === "PowerState/stopped") {
+      const result = {
+        costRisk,
+        reason: "VM is stopped. ",
+        suspectedUnused: true,
+      };
+      verboseLogAnalysisResult(verbose, result);
+      return result;
+    }
+  } catch (error) {
+    const logger = getLogger(["savemoney", "azure"]);
+    logger.warn(
+      `Failed to get VM instance view for ${vmName}: ${error instanceof Error ? error.message : error}`,
+    );
+    // Continue with metric analysis if instance view fails
+  }
+
+  // Check metrics for low utilization
+  const cpuUsage = await getMetric(
+    monitorClient,
+    resource.id,
+    "Percentage CPU",
+    "Average",
+    timespanDays,
+  );
+  const networkIn = await getMetric(
+    monitorClient,
+    resource.id,
+    "Network In Total",
+    "Total",
+    timespanDays,
+  );
+
+  if (cpuUsage !== null && cpuUsage < 1) {
+    // Less than 1% average CPU
+    reason += `Low CPU usage (avg ${cpuUsage.toFixed(2)}%). `;
+  }
+  if (networkIn !== null && networkIn < 1024 * 1024 * 10) {
+    // Less than 10MB total network in
+    reason += `Low network traffic. `;
+  }
+
+  const result = { costRisk, reason, suspectedUnused: reason.length > 0 };
+  verboseLogAnalysisResult(verbose, result);
+  return result;
+}

package/src/azure/types.ts

@@ -0,0 +1,38 @@
+/**
+ * Azure-specific types
+ */
+
+import type * as armResources from "@azure/arm-resources";
+
+import type { AnalysisResult, BaseConfig, CostRisk } from "../types.js";
+
+/**
+ * Azure configuration extending base config
+ */
+export type AzureConfig = BaseConfig & {
+  subscriptionIds: string[];
+  tenantId: string;
+  verbose?: boolean;
+};
+
+/**
+ * Detailed report for a single Azure resource with full resource object
+ */
+export type AzureDetailedResourceReport = {
+  analysis: AnalysisResult;
+  resource: armResources.GenericResource;
+};
+
+/**
+ * Summary report for a single Azure resource
+ */
+export type AzureResourceReport = {
+  costRisk: CostRisk;
+  location?: string;
+  name: string;
+  reason: string;
+  resourceGroup?: string;
+  subscriptionId: string;
+  suspectedUnused: boolean;
+  type: string;
+};

package/src/azure/utils.ts

@@ -0,0 +1,141 @@
+/**
+ * Azure utility functions for debugging and metrics
+ */
+
+import type { MonitorClient } from "@azure/arm-monitor";
+
+import { getLogger } from "@logtape/logtape";
+
+import type { AnalysisResult } from "../types.js";
+
+/**
+ * Fetches a specific metric for a resource from Azure Monitor.
+ *
+ * @param monitorClient - The Azure Monitor client instance
+ * @param resourceId - The Azure resource ID
+ * @param metricName - The name of the metric to fetch (e.g., "Percentage CPU")
+ * @param aggregation - The aggregation type (e.g., "Average", "Total")
+ * @param timespanDays - Number of days to look back for metrics
+ * @returns The metric value or null if unavailable
+ */
+export async function getMetric(
+  monitorClient: MonitorClient,
+  resourceId: string,
+  metricName: string,
+  aggregation: string,
+  timespanDays: number,
+): Promise<null | number> {
+  try {
+    const timespan = `P${timespanDays}D`;
+    const result = await monitorClient.metrics.list(resourceId, {
+      aggregation,
+      metricnames: metricName,
+      timespan,
+    });
+
+    const metricData = result.value[0]?.timeseries?.[0]?.data?.[0];
+    if (!metricData) {
+      return null;
+    }
+
+    const aggregationLower = aggregation.toLowerCase();
+
+    if (
+      aggregationLower === "average" &&
+      typeof metricData.average === "number"
+    ) {
+      return metricData.average;
+    }
+    if (aggregationLower === "total" && typeof metricData.total === "number") {
+      return metricData.total;
+    }
+    if (
+      aggregationLower === "minimum" &&
+      typeof metricData.minimum === "number"
+    ) {
+      return metricData.minimum;
+    }
+    if (
+      aggregationLower === "maximum" &&
+      typeof metricData.maximum === "number"
+    ) {
+      return metricData.maximum;
+    }
+    if (aggregationLower === "count" && typeof metricData.count === "number") {
+      return metricData.count;
+    }
+
+    return null;
+  } catch (error) {
+    const logger = getLogger(["savemoney", "azure", "metrics"]);
+    logger.error(
+      `Failed to fetch metric ${metricName} for resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return null;
+  }
+}
+
+/**
+ * Logs a verbose message, optionally with an object.
+ *
+ * @param verbose - Whether verbose logging is enabled
+ * @param message - The message to log
+ * @param object - Optional object to stringify and log
+ */
+export function verboseLog(
+  verbose: boolean,
+  message: string,
+  object?: unknown,
+) {
+  if (verbose) {
+    const logger = getLogger(["savemoney", "azure", "verbose"]);
+    if (object !== undefined) {
+      logger.debug(`${message} ${JSON.stringify(object, null, 2)}`);
+    } else {
+      logger.debug(message);
+    }
+  }
+}
+
+/**
+ * Logs the analysis result for a resource.
+ *
+ * @param verbose - Whether verbose logging is enabled
+ * @param result - The analysis result object
+ */
+export function verboseLogAnalysisResult(
+  verbose: boolean,
+  result: AnalysisResult,
+) {
+  if (verbose) {
+    const logger = getLogger(["savemoney", "azure", "verbose"]);
+    logger.debug("\n📊 ANALYSIS RESULT:");
+    logger.debug(`   Cost Risk: ${result.costRisk.toUpperCase()}`);
+    logger.debug(
+      `   Suspected Unused: ${result.suspectedUnused ? "YES" : "NO"}`,
+    );
+    logger.debug(`   Reason: ${result.reason || "No issues found"}`);
+    logger.debug("=".repeat(80) + "\n");
+  }
+}
+
+/**
+ * Logs a resource analysis header with visual separator.
+ *
+ * @param verbose - Whether verbose logging is enabled
+ * @param resourceName - Name of the resource being analyzed
+ * @param resourceType - Type of the resource
+ */
+export function verboseLogResourceStart(
+  verbose: boolean,
+  resourceName: string,
+  resourceType: string,
+) {
+  if (verbose) {
+    const logger = getLogger(["savemoney", "azure", "verbose"]);
+    logger.debug("\n" + "=".repeat(80));
+    logger.debug(`🔍 ANALYZING: ${resourceName}`);
+    logger.debug(`   Type: ${resourceType}`);
+    logger.debug("=".repeat(80));
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+
+import type { AnalysisResult } from "./index.js";
+
+import { mergeResults } from "./index.js";
+
+describe("mergeResults", () => {
+  it("should concatenate reasons from both results", () => {
+    const baseResult: AnalysisResult = {
+      costRisk: "low",
+      reason: "No tags found. ",
+      suspectedUnused: true,
+    };
+    const specificResult: AnalysisResult = {
+      costRisk: "medium",
+      reason: "Disk is unattached. ",
+      suspectedUnused: true,
+    };
+
+    const merged = mergeResults(baseResult, specificResult);
+
+    expect(merged.reason).toBe("No tags found. Disk is unattached. ");
+    expect(merged.costRisk).toBe("medium");
+    expect(merged.suspectedUnused).toBe(true);
+  });
+
+  it("should use specific result's cost risk", () => {
+    const baseResult: AnalysisResult = {
+      costRisk: "low",
+      reason: "Base reason. ",
+      suspectedUnused: false,
+    };
+    const specificResult: AnalysisResult = {
+      costRisk: "high",
+      reason: "High risk reason. ",
+      suspectedUnused: true,
+    };
+
+    const merged = mergeResults(baseResult, specificResult);
+
+    expect(merged.costRisk).toBe("high");
+  });
+
+  it("should OR suspectedUnused flags", () => {
+    const baseResult: AnalysisResult = {
+      costRisk: "low",
+      reason: "Base. ",
+      suspectedUnused: false,
+    };
+    const specificResult: AnalysisResult = {
+      costRisk: "medium",
+      reason: "Specific. ",
+      suspectedUnused: true,
+    };
+
+    const merged = mergeResults(baseResult, specificResult);
+
+    expect(merged.suspectedUnused).toBe(true);
+  });
+
+  it("should handle empty reasons", () => {
+    const baseResult: AnalysisResult = {
+      costRisk: "low",
+      reason: "",
+      suspectedUnused: false,
+    };
+    const specificResult: AnalysisResult = {
+      costRisk: "medium",
+      reason: "Only specific reason. ",
+      suspectedUnused: false,
+    };
+
+    const merged = mergeResults(baseResult, specificResult);
+
+    expect(merged.reason).toBe("Only specific reason. ");
+  });
+
+  it("should preserve both reasons when both are present", () => {
+    const baseResult: AnalysisResult = {
+      costRisk: "low",
+      reason: "First issue. ",
+      suspectedUnused: true,
+    };
+    const specificResult: AnalysisResult = {
+      costRisk: "high",
+      reason: "Second issue. ",
+      suspectedUnused: false,
+    };
+
+    const merged = mergeResults(baseResult, specificResult);
+
+    expect(merged.reason).toBe("First issue. Second issue. ");
+    expect(merged.suspectedUnused).toBe(true); // true OR false = true
+  });
+});

package/src/index.ts

@@ -0,0 +1,99 @@
+/**
+ * SaveMoney Package
+ *
+ * A tool that analyzes cloud resources and reports potentially unused
+ * or cost-inefficient ones.
+ *
+ * Features:
+ * - Multi-cloud support (Azure, AWS planned)
+ * - Metric-based analysis
+ * - Multiple output formats (table, JSON, detailed-JSON)
+ * - Configurable via CLI options, environment variables, or config file
+ *
+ * This tool does NOT modify, tag, or delete any resources.
+ */
+
+// Export common types
+export type { AzureConfig } from "./azure/types.js";
+export * from "./types.js";
+
+// Export Azure module
+import * as azureModule from "./azure/index.js";
+export const azure = azureModule;
+
+import { getLogger } from "@logtape/logtape";
+// Utility imports for loadConfig and prompt functions
+import * as fs from "fs";
+import * as readline from "readline";
+
+import type { AzureConfig } from "./azure/types.js";
+
+/**
+ * Loads configuration from file, environment variables, or interactive prompts.
+ *
+ * @param configPath - Optional path to JSON configuration file
+ * @returns Configuration object with subscription IDs and settings
+ */
+export async function loadConfig(configPath?: string): Promise<AzureConfig> {
+  const logger = getLogger(["savemoney", "config"]);
+
+  if (configPath && fs.existsSync(configPath)) {
+    try {
+      const configContent = fs.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+
+      // Validate required fields
+      if (!config.tenantId || !config.subscriptionIds) {
+        throw new Error(
+          "Config file must contain 'tenantId' and 'subscriptionIds'",
+        );
+      }
+
+      return {
+        ...config,
+        preferredLocation: config.preferredLocation || "italynorth",
+        timespanDays: config.timespanDays || 30,
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to load config file: ${error instanceof Error ? error.message : error}`,
+      );
+    }
+  }
+
+  logger.info(
+    "Configuration file not found. Checking environment variables...",
+  );
+
+  const tenantId =
+    process.env.ARM_TENANT_ID || (await prompt("Enter Tenant ID: "));
+  const subscriptionIds = process.env.ARM_SUBSCRIPTION_ID
+    ? process.env.ARM_SUBSCRIPTION_ID.split(",")
+    : (await prompt("Enter Subscription IDs (comma-separated): ")).split(",");
+
+  return {
+    preferredLocation: "italynorth",
+    subscriptionIds,
+    tenantId,
+    timespanDays: 30,
+  };
+}
+
+/**
+ * Prompts user for input via stdin.
+ *
+ * @param question - The question to display to the user
+ * @returns User's input as a string
+ */
+export async function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) =>
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    }),
+  );
+}

package/src/types.ts

@@ -0,0 +1,34 @@
+/**
+ * Common types shared across all cloud providers
+ */
+
+export type AnalysisResult = {
+  costRisk: CostRisk;
+  reason: string;
+  suspectedUnused: boolean;
+};
+
+/**
+ * Base configuration interface that all cloud providers should extend
+ */
+export type BaseConfig = {
+  preferredLocation: string;
+  timespanDays: number;
+};
+
+export type CostRisk = "high" | "low" | "medium";
+
+/**
+ * Merges analysis results, preserving existing reasons and combining suspectedUnused flags.
+ */
+export function mergeResults(
+  baseResult: AnalysisResult,
+  specificResult: AnalysisResult,
+): AnalysisResult {
+  return {
+    costRisk: specificResult.costRisk,
+    reason: baseResult.reason + specificResult.reason,
+    suspectedUnused:
+      baseResult.suspectedUnused || specificResult.suspectedUnused,
+  };
+}