switch to approach that does commit signing

ashwin-ant · williammartin · commit 4d5f71904cde · 2025-05-12T13:17:53.000+02:00
diff --git a/pkg/github/repositories.go b/pkg/github/repositories.go
@@ -585,10 +585,6 @@ func DeleteFile(getClient GetClientFn, t translations.TranslationHelperFunc) (to
 				mcp.Required(),
 				mcp.Description("Branch to delete the file from"),
 			),
-			mcp.WithString("sha",
-				mcp.Required(),
-				mcp.Description("SHA of the file being deleted"),
-			),
 		),
 		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 			owner, err := requiredParam[string](request, "owner")
@@ -611,38 +607,70 @@ func DeleteFile(getClient GetClientFn, t translations.TranslationHelperFunc) (to
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
-			sha, err := requiredParam[string](request, "sha")
+
+			client, err := getClient(ctx)
 			if err != nil {
-				return mcp.NewToolResultError(err.Error()), nil
+				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
 			}
 
-			// Create the file options
-			opts := &github.RepositoryContentFileOptions{
-				Message: github.Ptr(message),
-				Branch:  github.Ptr(branch),
-				SHA:     github.Ptr(sha),
+			// Get the reference for the branch
+			ref, resp, err := client.Git.GetRef(ctx, owner, repo, "refs/heads/"+branch)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get branch reference: %w", err)
 			}
+			defer func() { _ = resp.Body.Close() }()
 
-			// Delete the file
-			client, err := getClient(ctx)
+			// Get the commit object that the branch points to
+			baseCommit, resp, err := client.Git.GetCommit(ctx, owner, repo, *ref.Object.SHA)
 			if err != nil {
-				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
+				return nil, fmt.Errorf("failed to get base commit: %w", err)
 			}
-			deleteResponse, resp, err := client.Repositories.DeleteFile(ctx, owner, repo, path, opts)
+			defer func() { _ = resp.Body.Close() }()
+
+			// Create a tree entry for the file deletion by setting SHA to nil
+			treeEntries := []*github.TreeEntry{
+				{
+					Path: github.Ptr(path),
+					Mode: github.Ptr("100644"), // Regular file mode
+					Type: github.Ptr("blob"),
+					SHA:  nil, // Setting SHA to nil deletes the file
+				},
+			}
+
+			// Create a new tree with the deletion
+			newTree, resp, err := client.Git.CreateTree(ctx, owner, repo, *baseCommit.Tree.SHA, treeEntries)
 			if err != nil {
-				return nil, fmt.Errorf("failed to delete file: %w", err)
+				return nil, fmt.Errorf("failed to create tree: %w", err)
 			}
 			defer func() { _ = resp.Body.Close() }()
 
-			if resp.StatusCode != 200 && resp.StatusCode != 204 {
-				body, err := io.ReadAll(resp.Body)
-				if err != nil {
-					return nil, fmt.Errorf("failed to read response body: %w", err)
-				}
-				return mcp.NewToolResultError(fmt.Sprintf("failed to delete file: %s", string(body))), nil
+			// Create a new commit with the new tree
+			commit := &github.Commit{
+				Message: github.Ptr(message),
+				Tree:    newTree,
+				Parents: []*github.Commit{{SHA: baseCommit.SHA}},
+			}
+			newCommit, resp, err := client.Git.CreateCommit(ctx, owner, repo, commit, nil)
+			if err != nil {
+				return nil, fmt.Errorf("failed to create commit: %w", err)
+			}
+			defer func() { _ = resp.Body.Close() }()
+
+			// Update the branch reference to point to the new commit
+			ref.Object.SHA = newCommit.SHA
+			_, resp, err = client.Git.UpdateRef(ctx, owner, repo, ref, false)
+			if err != nil {
+				return nil, fmt.Errorf("failed to update reference: %w", err)
+			}
+			defer func() { _ = resp.Body.Close() }()
+
+			// Create a response similar to what the DeleteFile API would return
+			response := map[string]interface{}{
+				"commit": newCommit,
+				"content": nil,
 			}
 
-			r, err := json.Marshal(deleteResponse)
+			r, err := json.Marshal(response)
 			if err != nil {
 				return nil, fmt.Errorf("failed to marshal response: %w", err)
 			}
diff --git a/pkg/github/repositories_test.go b/pkg/github/repositories_test.go
@@ -1541,49 +1541,96 @@ func Test_DeleteFile(t *testing.T) {
 	assert.Contains(t, tool.InputSchema.Properties, "path")
 	assert.Contains(t, tool.InputSchema.Properties, "message")
 	assert.Contains(t, tool.InputSchema.Properties, "branch")
-	assert.Contains(t, tool.InputSchema.Properties, "sha")
-	assert.ElementsMatch(t, tool.InputSchema.Required, []string{"owner", "repo", "path", "message", "branch", "sha"})
+	// SHA is no longer required since we're using Git Data API
+	assert.ElementsMatch(t, tool.InputSchema.Required, []string{"owner", "repo", "path", "message", "branch"})
 
-	// Setup mock delete response
-	mockDeleteResponse := &github.RepositoryContentResponse{
-		Content: &github.RepositoryContent{
-			Name:    github.Ptr("example.md"),
-			Path:    github.Ptr("docs/example.md"),
-			SHA:     github.Ptr("abc123def456"),
-			HTMLURL: github.Ptr("https://github.com/owner/repo/blob/main/docs/example.md"),
+	// Setup mock objects for Git Data API
+	mockRef := &github.Reference{
+		Ref: github.Ptr("refs/heads/main"),
+		Object: &github.GitObject{
+			SHA: github.Ptr("abc123"),
 		},
-		Commit: github.Commit{
-			SHA:     github.Ptr("def456abc789"),
-			Message: github.Ptr("Delete example file"),
-			Author: &github.CommitAuthor{
-				Name:  github.Ptr("Test User"),
-				Email: github.Ptr("test@example.com"),
-				Date:  &github.Timestamp{Time: time.Now()},
-			},
-			HTMLURL: github.Ptr("https://github.com/owner/repo/commit/def456abc789"),
+	}
+
+	mockCommit := &github.Commit{
+		SHA: github.Ptr("abc123"),
+		Tree: &github.Tree{
+			SHA: github.Ptr("def456"),
 		},
 	}
 
+	mockTree := &github.Tree{
+		SHA: github.Ptr("ghi789"),
+	}
+
+	mockNewCommit := &github.Commit{
+		SHA:     github.Ptr("jkl012"),
+		Message: github.Ptr("Delete example file"),
+		HTMLURL: github.Ptr("https://github.com/owner/repo/commit/jkl012"),
+	}
+
 	tests := []struct {
-		name           string
-		mockedClient   *http.Client
-		requestArgs    map[string]interface{}
-		expectError    bool
-		expectedResult *github.RepositoryContentResponse
-		expectedErrMsg string
+		name             string
+		mockedClient     *http.Client
+		requestArgs      map[string]interface{}
+		expectError      bool
+		expectedCommitSHA string
+		expectedErrMsg   string
 	}{
 		{
-			name: "successful file deletion",
+			name: "successful file deletion using Git Data API",
 			mockedClient: mock.NewMockedHTTPClient(
+				// Get branch reference
+				mock.WithRequestMatch(
+					mock.GetReposGitRefByOwnerByRepoByRef,
+					mockRef,
+				),
+				// Get commit
+				mock.WithRequestMatch(
+					mock.GetReposGitCommitsByOwnerByRepoByCommitSha,
+					mockCommit,
+				),
+				// Create tree
+				mock.WithRequestMatchHandler(
+					mock.PostReposGitTreesByOwnerByRepo,
+					expectRequestBody(t, map[string]interface{}{
+						"base_tree": "def456",
+						"tree": []interface{}{
+							map[string]interface{}{
+								"path":    "docs/example.md",
+								"mode":    "100644",
+								"type":    "blob",
+								"sha":     nil,
+							},
+						},
+					}).andThen(
+						mockResponse(t, http.StatusCreated, mockTree),
+					),
+				),
+				// Create commit
 				mock.WithRequestMatchHandler(
-					mock.DeleteReposContentsByOwnerByRepoByPath,
+					mock.PostReposGitCommitsByOwnerByRepo,
 					expectRequestBody(t, map[string]interface{}{
 						"message": "Delete example file",
-						"branch":  "main",
-						"sha":     "abc123def456",
-						"content": interface{}(nil),
+						"tree":    "ghi789",
+						"parents": []interface{}{"abc123"},
+					}).andThen(
+						mockResponse(t, http.StatusCreated, mockNewCommit),
+					),
+				),
+				// Update reference
+				mock.WithRequestMatchHandler(
+					mock.PatchReposGitRefsByOwnerByRepoByRef,
+					expectRequestBody(t, map[string]interface{}{
+						"sha":   "jkl012",
+						"force": false,
 					}).andThen(
-						mockResponse(t, http.StatusOK, mockDeleteResponse),
+						mockResponse(t, http.StatusOK, &github.Reference{
+							Ref: github.Ptr("refs/heads/main"),
+							Object: &github.GitObject{
+								SHA: github.Ptr("jkl012"),
+							},
+						}),
 					),
 				),
 			),
@@ -1593,19 +1640,18 @@ func Test_DeleteFile(t *testing.T) {
 				"path":    "docs/example.md",
 				"message": "Delete example file",
 				"branch":  "main",
-				"sha":     "abc123def456",
 			},
-			expectError:    false,
-			expectedResult: mockDeleteResponse,
+			expectError:        false,
+			expectedCommitSHA: "jkl012",
 		},
 		{
-			name: "file deletion fails",
+			name: "file deletion fails - branch not found",
 			mockedClient: mock.NewMockedHTTPClient(
 				mock.WithRequestMatchHandler(
-					mock.DeleteReposContentsByOwnerByRepoByPath,
+					mock.GetReposGitRefByOwnerByRepoByRef,
 					http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 						w.WriteHeader(http.StatusNotFound)
-						_, _ = w.Write([]byte(`{"message": "Not Found"}`))
+						_, _ = w.Write([]byte(`{"message": "Reference not found"}`))
 					}),
 				),
 			),
@@ -1614,11 +1660,10 @@ func Test_DeleteFile(t *testing.T) {
 				"repo":    "repo",
 				"path":    "docs/nonexistent.md",
 				"message": "Delete nonexistent file",
-				"branch":  "main",
-				"sha":     "abc123def456",
+				"branch":  "nonexistent-branch",
 			},
 			expectError:    true,
-			expectedErrMsg: "failed to delete file",
+			expectedErrMsg: "failed to get branch reference",
 		},
 	}
 
@@ -1647,20 +1692,16 @@ func Test_DeleteFile(t *testing.T) {
 			textContent := getTextResult(t, result)
 
 			// Unmarshal and verify the result
-			var returnedContent github.RepositoryContentResponse
-			err = json.Unmarshal([]byte(textContent.Text), &returnedContent)
+			var response map[string]interface{}
+			err = json.Unmarshal([]byte(textContent.Text), &response)
 			require.NoError(t, err)
 
-			// Verify content
-			if tc.expectedResult.Content != nil {
-				assert.Equal(t, *tc.expectedResult.Content.Name, *returnedContent.Content.Name)
-				assert.Equal(t, *tc.expectedResult.Content.Path, *returnedContent.Content.Path)
-				assert.Equal(t, *tc.expectedResult.Content.SHA, *returnedContent.Content.SHA)
-			}
-
-			// Verify commit
-			assert.Equal(t, *tc.expectedResult.Commit.SHA, *returnedContent.Commit.SHA)
-			assert.Equal(t, *tc.expectedResult.Commit.Message, *returnedContent.Commit.Message)
+			// Verify the response contains the expected commit
+			commit, ok := response["commit"].(map[string]interface{})
+			require.True(t, ok)
+			commitSHA, ok := commit["sha"].(string)
+			require.True(t, ok)
+			assert.Equal(t, tc.expectedCommitSHA, commitSHA)
 		})
 	}
 }
