feat: CP-1068 Create MCP tool to bump timestamp of a project

Author: samueld-activator

cmd/state-mcp/internal/registry/registry.go

@@ -38,6 +38,7 @@ func New() *Registry {
 	r.RegisterTool(DownloadSourceFileTool())
 	r.RegisterTool(GetIngredientDetailsTool())
 	r.RegisterTool(CreateIngredientRevisionTool())
+	r.RegisterTool(RebuildProjectTool())
 
 	r.RegisterPrompt(ProjectPrompt())
 	r.RegisterPrompt(IngredientPrompt())

cmd/state-mcp/internal/registry/tools.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ActiveState/cli/internal/runners/mcp/downloadsource"
 	"github.com/ActiveState/cli/internal/runners/mcp/ingredientdetails"
 	"github.com/ActiveState/cli/internal/runners/mcp/projecterrors"
+	"github.com/ActiveState/cli/internal/runners/mcp/rebuildproject"
 	"github.com/ActiveState/cli/pkg/project"
 	"github.com/mark3labs/mcp-go/mcp"
 )
@@ -297,3 +298,37 @@ func CreateIngredientRevisionTool() Tool {
 		},
 	}
 }
+
+func RebuildProjectTool() Tool {
+	return Tool{
+		Category: CategoryDebug,
+		Tool: mcp.NewTool(
+			"rebuild_project",
+			mcp.WithDescription("Triggers a project rebuild after all errors have been addressed"),
+			mcp.WithString("project", mcp.Description("Project namespace in format 'owner/project'"), mcp.Required()),
+		),
+		Handler: func(ctx context.Context, p *primer.Values, mcpRequest mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			namespace, err := mcpRequest.RequireString("project")
+			if err != nil {
+				return mcp.NewToolResultError(fmt.Sprintf("a project in the format 'owner/project' is required: %s", errs.JoinMessage(err))), nil
+			}
+			ns, err := project.ParseNamespace(namespace)
+			if err != nil {
+				return mcp.NewToolResultError(fmt.Sprintf("error parsing project namespace: %s", errs.JoinMessage(err))), nil
+			}
+
+			params := rebuildproject.NewParams(ns)
+			runner := rebuildproject.New(p)
+
+			err = runner.Run(params)
+
+			if err != nil {
+				return mcp.NewToolResultError(fmt.Sprintf("error rebuilding project: %s", errs.JoinMessage(err))), nil
+			}
+
+			return mcp.NewToolResultText(
+				strings.Join(p.Output().History().Print, "\n"),
+			), nil
+		},
+	}
+}

internal/runners/mcp/rebuildproject/rebuildproject.go

@@ -0,0 +1,88 @@
+package rebuildproject
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/ActiveState/cli/internal/captain"
+	"github.com/ActiveState/cli/internal/errs"
+	"github.com/ActiveState/cli/internal/output"
+	"github.com/ActiveState/cli/internal/primer"
+	"github.com/ActiveState/cli/internal/runbits/commits_runbit"
+	"github.com/ActiveState/cli/pkg/platform/authentication"
+	"github.com/ActiveState/cli/pkg/platform/model"
+	bpModel "github.com/ActiveState/cli/pkg/platform/model/buildplanner"
+	"github.com/ActiveState/cli/pkg/project"
+)
+
+type ProjectErrorsRunner struct {
+	auth     *authentication.Auth
+	output   output.Outputer
+	svcModel *model.SvcModel
+}
+
+func New(p *primer.Values) *ProjectErrorsRunner {
+	return &ProjectErrorsRunner{
+		auth:     p.Auth(),
+		output:   p.Output(),
+		svcModel: p.SvcModel(),
+	}
+}
+
+type Params struct {
+	project *project.Namespaced
+}
+
+func NewParams(project *project.Namespaced) *Params {
+	return &Params{
+		project: project,
+	}
+}
+
+func (runner *ProjectErrorsRunner) Run(params *Params) error {
+	branch, err := model.DefaultBranchForProjectName(params.project.Owner, params.project.Project)
+	if err != nil {
+		return fmt.Errorf("error fetching default branch: %w", err)
+	}
+
+	// Collect "before" buildplan
+	bpm := bpModel.NewBuildPlannerModel(runner.auth, runner.svcModel)
+	localCommit, err := bpm.FetchCommit(*branch.CommitID, params.project.Owner, params.project.Project, nil)
+	if err != nil {
+		return errs.Wrap(err, "Failed to fetch build result")
+	}
+
+	// Collect "after" buildplan
+	bumpedBS, err := localCommit.BuildScript().Clone()
+	if err != nil {
+		return errs.Wrap(err, "Failed to clone build script")
+	}
+
+	now := captain.TimeValue{}
+	now.Set("now")
+	ts, err := commits_runbit.ExpandTime(&now, runner.auth)
+	if err != nil {
+		return errs.Wrap(err, "Failed to fetch latest timestamp")
+	}
+	bumpedBS.SetAtTime(ts, true)
+
+	// Since our platform is commit based we need to create a commit for the "after" buildplan, even though we may not
+	// end up using it it the user doesn't confirm the upgrade.
+	bumpedCommit, err := bpm.StageCommitAndPoll(bpModel.StageCommitParams{
+		Owner:        params.project.Owner,
+		Project:      params.project.Project,
+		ParentCommit: branch.CommitID.String(),
+		Script:       bumpedBS,
+	})
+	if err != nil {
+		return errs.Wrap(err, "Failed to stage bumped commit")
+	}
+
+	jsonBytes, err := json.Marshal(bumpedCommit)
+	if err != nil {
+		return fmt.Errorf("error marshaling results: %w", err)
+	}
+	runner.output.Print(string(jsonBytes))
+
+	return nil
+}