In Full Match you get everything that regex says about, even non-capturing groups. You need to get appropriate Match to get rid of non-capturing groups. The other solution is to use positive lookahead instead of capturing group. Check the regex below. I also removed some unnecessary (IMO) groups.

(?:Bundle\s+Components|Included\s+Components)\s+.*?(?=Bundle)

It results with only one, full, match.

Demo

PS: The sign of new line just before "Bundle" will be captured as well in this solution.

You need to make the String part optional by using a ?:

String regexFilter = "(?:String )?(Transformation) (Action)";

Also, there isn't much point in putting capturing groups around literal text (e.g. Transformation and Action) since you always know what those groups will capture.

String regexFilter = "(?:String )?Transformation Action";

A non-capturing group does not capture, but still matches the string. Besides, there is a space between the digits and the newline in your pattern, so it won't match.

To get the digits, you would use a capturing group around the digit matching pattern, like this:

Pattern p = Pattern.compile("Game No : ([0-9]+)");
Matcher m = p.matcher(curr);
if (m.find()) {
    System.out.print(m.group(1));
}

See the Java demo

Or, use a non-regex solution, just split with : and get the second item of the resulting array and trim it.

Consider input:

/path/foo/a/b/script/file

Regex matches as follows:

^                 Ok: No text before here
/path/foo         "/path/foo"
(?:/[^/]+)*       "/a/b/script"
(?!/script)       Ok: Text after here is "/file"
/                 "/"
[^/]*             "file"
$                 Ok: No text after here

What you wanted is a negative lookbehind, not a negative lookahead:

^                 Ok: No text before here
/path/foo         "/path/foo"
(?:/[^/]+)*       "/a/b/script"
(?<!/script)      Fail: Text before here is "/script"
/                 "/"
[^/]*             "file"
$                 Ok: No text after here

It means that the grouping is atomic, and it throws away backtracking information for a matched group. So, this expression is possessive; it won't back off even if doing so is the only way for the regex as a whole to succeed. It's "independent" in the sense that it doesn't cooperate, via backtracking, with other elements of the regex to ensure a match.

Why not use look-ahead / look-behind instead?

They are non-capturing and would work easily here:

str = str
    .replaceAll(
        "(?<=\\[assembly: AssemblyVersion\\(\"\\d\\.\\d\\.).*(?=\"\\)\\])",      
        "4.0"
    );