feat: [CCM-24165]: Support for Commitment Utilization (#94)

* Fix typos

* Apply suggestion from code review

* Update error handling to return tool wrapped error

* Update README

* Add support to include Commitment Utilisation Tool call

Author: sandyydk

README.md

@@ -122,6 +122,7 @@ Toolset Name: `ccm`
 - `get_ccm_recommendations_stats`: Returns overall statistics for cloud cost optimization recommendations within a given account in Harness Cloud Cost Management.
 - `get_ccm_commitment_coverage`: Get commitment coverage information for an account in Harness Cloud Cost Management
 - `get_ccm_commitment_savings`: Get commitment savings information for an account in Harness Cloud Cost Management
+- `get_ccm_commitment_utilisation`: Get commitment utilisation information for an account in Harness Cloud Cost Management broken down by Reserved Instances and Savings Plans in day wise granularity.
 
 #### Database Operations Toolset
 

client/ccmcosts.go

@@ -11,16 +11,16 @@ import (
 )
 
 const (
-	ccmBasePath                      = "ccm/api"
-	ccmCommitmentBasePath            = "/lw/co/api"
-	ccmGetOverviewPath               = ccmBasePath + "/overview?accountIdentifier=%s&startTime=%d&endTime=%d&groupBy=%s"
-	ccmCostCategoryListPath          = ccmBasePath + "/business-mapping/filter-panel?accountIdentifier=%s"
-	ccmCostCategoryDetailListPath    = ccmBasePath + "/business-mapping?accountIdentifier=%s"    // This endpoint lists cost categories
-	ccmGetCostCategoryPath           = ccmBasePath + "/business-mapping/%s?accountIdentifier=%s" // This endpoint lists cost categories
-	ccmCommitmentCoverageDetailsPath = ccmCommitmentBasePath + "/accounts/%s/v1/detail/compute_coverage?accountIdentifier=%s"
-	ccmCommitmentSavingsDetailsPath  = ccmCommitmentBasePath + "/accounts/%s/v1/detail/savings?accountIdentifier=%s"
-
-	ccmCommitmentComputeService string = "Amazon Elastic Compute Cloud - Compute"
+	ccmBasePath                                = "ccm/api"
+	ccmCommitmentBasePath                      = "/lw/co/api"
+	ccmGetOverviewPath                         = ccmBasePath + "/overview?accountIdentifier=%s&startTime=%d&endTime=%d&groupBy=%s"
+	ccmCostCategoryListPath                    = ccmBasePath + "/business-mapping/filter-panel?accountIdentifier=%s"
+	ccmCostCategoryDetailListPath              = ccmBasePath + "/business-mapping?accountIdentifier=%s"    // This endpoint lists cost categories
+	ccmGetCostCategoryPath                     = ccmBasePath + "/business-mapping/%s?accountIdentifier=%s" // This endpoint lists cost categories
+	ccmCommitmentCoverageDetailsPath           = ccmCommitmentBasePath + "/accounts/%s/v1/detail/compute_coverage?accountIdentifier=%s"
+	ccmCommitmentSavingsDetailsPath            = ccmCommitmentBasePath + "/accounts/%s/v1/detail/savings?accountIdentifier=%s"
+	ccmCommitmentUtilisationDetailsPath        = ccmCommitmentBasePath + "/accounts/%s/v1/detail/commitment_utilisation?accountIdentifier=%s"
+	ccmCommitmentComputeService         string = "Amazon Elastic Compute Cloud - Compute"
 )
 
 type CloudCostManagementService struct {
@@ -237,3 +237,50 @@ func (r *CloudCostManagementService) GetCommitmentSavings(ctx context.Context, s
 
 	return savingsResponse, nil
 }
+
+func (r *CloudCostManagementService) GetCommitmentUtilisation(ctx context.Context, scope dto.Scope, opts *dto.CCMCommitmentOptions) (*dto.CCMCommitmentBaseResponse, error) {
+	path := fmt.Sprintf(ccmCommitmentUtilisationDetailsPath, scope.AccountID, scope.AccountID)
+	params := make(map[string]string)
+	addScope(scope, params)
+
+	// Handle nil options by creating default options
+	if opts == nil {
+		opts = &dto.CCMCommitmentOptions{}
+	}
+
+	if opts.StartDate != nil && *opts.StartDate != "" {
+		params["start_date"] = *opts.StartDate
+	} else {
+		// Default to last 30 days
+		params["start_date"] = utils.FormatUnixToMMDDYYYY(time.Now().AddDate(0, 0, -30).Unix())
+	}
+	if opts.EndDate != nil && *opts.EndDate != "" {
+		params["end_date"] = *opts.EndDate
+	} else {
+		// Default to last 30 days
+		params["end_date"] = utils.CurrentMMDDYYYY()
+	}
+
+	var requestPayload = dto.CCMCommitmentAPIFilter{
+		Service: ccmCommitmentComputeService, // Default value
+
+	}
+
+	if opts.Service != nil && *opts.Service != "" {
+		requestPayload.Service = *opts.Service
+	}
+
+	if len(opts.CloudAccountIDs) > 0 {
+		requestPayload.CloudAccounts = opts.CloudAccountIDs
+	}
+
+	// Temporary slice to hold the strings
+	utilisationResponse := new(dto.CCMCommitmentBaseResponse)
+
+	err := r.Client.Post(ctx, path, params, requestPayload, utilisationResponse)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get cloud cost managment compute utilisation with path %s: %w", path, err)
+	}
+
+	return utilisationResponse, nil
+}

pkg/harness/tools/ccmcosts.go

@@ -4,13 +4,14 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"time"
+
 	"github.com/harness/harness-mcp/client"
 	"github.com/harness/harness-mcp/client/dto"
 	"github.com/harness/harness-mcp/cmd/harness-mcp-server/config"
 	"github.com/harness/harness-mcp/pkg/utils"
 	"github.com/mark3labs/mcp-go/mcp"
 	"github.com/mark3labs/mcp-go/server"
-	"time"
 )
 
 // GetCcmOverview creates a tool for getting a ccm overview from an account
@@ -357,12 +358,12 @@ func FetchCommitmentCoverageTool(config *config.Config, client *client.CloudCost
 
 			data, err := client.GetComputeCoverage(ctx, scope, params)
 			if err != nil {
-				return nil, fmt.Errorf("failed to get commitment coverage: %w", err)
+				return mcp.NewToolResultError(fmt.Sprintf("failed to get commitment coverage: %s", err)), nil
 			}
 
 			r, err := json.Marshal(data)
 			if err != nil {
-				return nil, fmt.Errorf("failed to marshal commitment coverage: %w", err)
+				return mcp.NewToolResultError(fmt.Sprintf("failed to marshal commitment coverage: %s", err)), nil
 			}
 
 			return mcp.NewToolResultText(string(r)), nil
@@ -454,12 +455,96 @@ func FetchCommitmentSavingsTool(config *config.Config, client *client.CloudCostM
 
 			data, err := client.GetCommitmentSavings(ctx, scope, params)
 			if err != nil {
-				return nil, fmt.Errorf("failed to get commitment savings: %w", err)
+				return mcp.NewToolResultError(fmt.Sprintf("failed to get commitment savings: %s", err)), nil
+			}
+
+			r, err := json.Marshal(data)
+			if err != nil {
+				return mcp.NewToolResultError(fmt.Sprintf("failed to marshal commitment savings: %s", err)), nil
+			}
+
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}
+
+func FetchCommitmentUtilisationTool(config *config.Config, client *client.CloudCostManagementService) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("get_ccm_commitment_utilisation",
+			mcp.WithDescription("Get commitment utilisation information for an account in Harness Cloud Cost Management broken down by Reserved Instances and Savings Plans in day wise granularity"),
+			mcp.WithString("start_date",
+				mcp.Description("Start date to filter commitment utilisation (optional, defaults to 30 days ago)"),
+			),
+			mcp.WithString("end_date",
+				mcp.Description("End date to filter commitment utilisation (optional, defaults to current date)"),
+			),
+			mcp.WithString("service",
+				mcp.Description("Optional service to filter commitment utilisation"),
+			),
+			mcp.WithArray("cloud_account_ids",
+				mcp.Description("Optional cloud account IDs to filter commitment utilisation"),
+				mcp.Items(map[string]any{
+					"type": "string",
+				}),
+			),
+			WithScope(config, false),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			accountId, err := getAccountID(config, request)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			params := &dto.CCMCommitmentOptions{}
+			params.AccountIdentifier = &accountId
+
+			// Handle service parameter
+			service, ok, err := OptionalParamOK[string](request, "service")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			if ok && service != "" {
+				params.Service = &service
+			}
+
+			// Handle cloud account IDs parameter
+			cloudAccountIDs, ok, err := OptionalParamOK[[]string](request, "cloud_account_ids")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			if ok && len(cloudAccountIDs) > 0 {
+				params.CloudAccountIDs = cloudAccountIDs
+			}
+
+			// Handle start date parameter
+			startDate, ok, err := OptionalParamOK[string](request, "start_date")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			if ok && startDate != "" {
+				params.StartDate = &startDate
+			}
+
+			// Handle end date parameter
+			endDate, ok, err := OptionalParamOK[string](request, "end_date")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			if ok && endDate != "" {
+				params.EndDate = &endDate
+			}
+
+			scope, err := FetchScope(config, request, false)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			data, err := client.GetCommitmentUtilisation(ctx, scope, params)
+			if err != nil {
+				return mcp.NewToolResultError(fmt.Sprintf("failed to get commitment utilisation: %s", err)), nil
 			}
 
 			r, err := json.Marshal(data)
 			if err != nil {
-				return nil, fmt.Errorf("failed to marshal commitment savings: %w", err)
+				return mcp.NewToolResultError(fmt.Sprintf("failed to marshal commitment utilisation: %s", err)), nil
 			}
 
 			return mcp.NewToolResultText(string(r)), nil

pkg/modules/ccm.go

@@ -101,6 +101,7 @@ func RegisterCloudCostManagement(config *config.Config, tsg *toolsets.ToolsetGro
 			toolsets.NewServerTool(tools.GetCcmRecommendationsStatsTool(config, ccmClient)),
 			toolsets.NewServerTool(tools.FetchCommitmentCoverageTool(config, ccmClient)),
 			toolsets.NewServerTool(tools.FetchCommitmentSavingsTool(config, ccmClient)),
+			toolsets.NewServerTool(tools.FetchCommitmentUtilisationTool(config, ccmClient)),
 		)
 
 	// Add toolset to the group